--- /srv/reproducible-results/rbuild-debian/r-b-build.snkFhYLF/b1/rustc-web_1.78.0+dfsg1-2~deb12u3_amd64.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.snkFhYLF/b2/rustc-web_1.78.0+dfsg1-2~deb12u3_amd64.changes ├── Files │ @@ -1,18 +1,18 @@ │ │ 9341158ddc09baa8d8fa7dcd0e433653 66934500 debug optional cargo-web-dbgsym_1.78.0+dfsg1-2~deb12u3_amd64.deb │ a18480fbacd18f0e9ded738a713fa6ee 4104568 doc optional cargo-web-doc_1.78.0+dfsg1-2~deb12u3_all.deb │ 12fa4f6edc60a7d3fe4369025d29d25f 6104840 devel optional cargo-web_1.78.0+dfsg1-2~deb12u3_amd64.deb │ c3bfdd1a05c57003ceb9d3fa2cf5d24e 231766268 debug optional libstd-rust-web-1.78-dbgsym_1.78.0+dfsg1-2~deb12u3_amd64.deb │ ce9f3e8ece6769ac93e4b2133856e7da 19605860 libs optional libstd-rust-web-1.78_1.78.0+dfsg1-2~deb12u3_amd64.deb │ - c47c1789c944761d8daa58379ddea6f9 41755692 libdevel optional libstd-rust-web-dev-windows_1.78.0+dfsg1-2~deb12u3_amd64.deb │ + 57e970f0441459184c9b020b36a2ff82 41756300 libdevel optional libstd-rust-web-dev-windows_1.78.0+dfsg1-2~deb12u3_amd64.deb │ d6a52cd71f34a7dae3c1ef530b8dfc75 37240536 libdevel optional libstd-rust-web-dev_1.78.0+dfsg1-2~deb12u3_amd64.deb │ e6b17ff62e8f518e68116b6c8a6aca6f 49661392 debug optional rust-web-clippy-dbgsym_1.78.0+dfsg1-2~deb12u3_amd64.deb │ ddbbe1990abd28c44f2080beb432ffc4 2629040 devel optional rust-web-clippy_1.78.0+dfsg1-2~deb12u3_amd64.deb │ - d9087ec5244ec15ceee7c3a7c3e4d863 20197408 doc optional rust-web-doc_1.78.0+dfsg1-2~deb12u3_all.deb │ + 81fa4f181d2f52497c5d53a697afd0cd 20034604 doc optional rust-web-doc_1.78.0+dfsg1-2~deb12u3_all.deb │ 01c40e2d9b7a3b468d95804c0414fe8c 225528 devel optional rust-web-gdb_1.78.0+dfsg1-2~deb12u3_all.deb │ 574d84dcae44861fd1830c230fc278e2 225740 devel optional rust-web-lldb_1.78.0+dfsg1-2~deb12u3_all.deb │ 8416b90db1a1c047c5277c7fde636bd7 21434860 devel optional rust-web-src_1.78.0+dfsg1-2~deb12u3_all.deb │ 748bf967708f46d98f2d0a34fc67b7e4 28614052 debug optional rustc-web-dbgsym_1.78.0+dfsg1-2~deb12u3_amd64.deb │ 5f59754b5010e24d510949183922c3d6 3237360 devel optional rustc-web_1.78.0+dfsg1-2~deb12u3_amd64.deb │ e2f5c19e6bc656825a484ba52e47b39b 21707264 debug optional rustfmt-web-dbgsym_1.78.0+dfsg1-2~deb12u3_amd64.deb │ b4d53fe56e4cdeaa6c9f353d83825fd8 2061132 devel optional rustfmt-web_1.78.0+dfsg1-2~deb12u3_amd64.deb ├── libstd-rust-web-dev-windows_1.78.0+dfsg1-2~deb12u3_amd64.deb │ ├── file list │ │ @@ -1,3 +1,3 @@ │ │ -rw-r--r-- 0 0 0 4 2024-08-28 14:44:23.000000 debian-binary │ │ -rw-r--r-- 0 0 0 2356 2024-08-28 14:44:23.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 41753144 2024-08-28 14:44:23.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 41753752 2024-08-28 14:44:23.000000 data.tar.xz │ ├── control.tar.xz │ │ ├── control.tar │ │ │ ├── ./md5sums │ │ │ │ ├── ./md5sums │ │ │ │ │┄ Files differ │ ├── data.tar.xz │ │ ├── data.tar │ │ │ ├── ./usr/lib/rustlib/x86_64-pc-windows-gnu/lib/libstd-77bb723fc58ce3d1.rlib │ │ │ │ ├── nm -s {} │ │ │ │ │┄ error from `nm -s {}`: │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.00.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.01.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.02.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.03.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.04.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.05.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.06.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.07.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.08.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.09.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.10.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.11.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.12.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.13.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.14.rcgu.o: no symbols │ │ │ │ │┄ nm: std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.15.rcgu.o: no symbols │ │ │ │ │ @@ -2290,20 +2290,20 @@ │ │ │ │ │ __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.104.llvm.10386673973210777259 in std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.15.rcgu.o │ │ │ │ │ __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.106.llvm.10386673973210777259 in std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.15.rcgu.o │ │ │ │ │ __imp__ZN3std3sys3pal7windows4time12perf_counter9frequency9FREQUENCY17hb6767d30e4f028d6E.0.llvm.10386673973210777259 in std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.15.rcgu.o │ │ │ │ │ __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.107.llvm.10386673973210777259 in std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.15.rcgu.o │ │ │ │ │ _ZN4core3ptr117drop_in_place$LT$std..sys_common..backtrace.._print_fmt..$u7b$$u7b$closure$u7d$$u7d$..$u7b$$u7b$closure$u7d$$u7d$$GT$17hc088a82a0fb7ebbfE.llvm.10386673973210777259 in std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.15.rcgu.o │ │ │ │ │ _ZN4core3ptr24drop_in_place$LT$i64$GT$17h92640e010cd0fa93E.llvm.10386673973210777259 in std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.15.rcgu.o │ │ │ │ │ _ZN3std3env7vars_os17h3b0b2c18e0b600f6E in std-77bb723fc58ce3d1.std.9f917a5e7a74ff1-cgu.15.rcgu.o │ │ │ │ │ -___tmp_rustcEEj9Ch_bcryptprimitives_lib_iname in bcryptprimitives.dllt.o │ │ │ │ │ -_head__tmp_rustcEEj9Ch_bcryptprimitives_lib in bcryptprimitives.dllh.o │ │ │ │ │ +___tmp_rustcRtCTVS_bcryptprimitives_lib_iname in bcryptprimitives.dllt.o │ │ │ │ │ +_head__tmp_rustcRtCTVS_bcryptprimitives_lib in bcryptprimitives.dllh.o │ │ │ │ │ ProcessPrng in bcryptprimitives.dlls00000.o │ │ │ │ │ __imp_ProcessPrng in bcryptprimitives.dlls00000.o │ │ │ │ │ -___tmp_rustcEEj9Ch_api_ms_win_core_synch_l1_2_0_lib_iname in api-ms-win-core-synch-l1-2-0.dllt.o │ │ │ │ │ -_head__tmp_rustcEEj9Ch_api_ms_win_core_synch_l1_2_0_lib in api-ms-win-core-synch-l1-2-0.dllh.o │ │ │ │ │ +___tmp_rustcRtCTVS_api_ms_win_core_synch_l1_2_0_lib_iname in api-ms-win-core-synch-l1-2-0.dllt.o │ │ │ │ │ +_head__tmp_rustcRtCTVS_api_ms_win_core_synch_l1_2_0_lib in api-ms-win-core-synch-l1-2-0.dllh.o │ │ │ │ │ WakeByAddressSingle in api-ms-win-core-synch-l1-2-0.dlls00002.o │ │ │ │ │ __imp_WakeByAddressSingle in api-ms-win-core-synch-l1-2-0.dlls00002.o │ │ │ │ │ WakeByAddressAll in api-ms-win-core-synch-l1-2-0.dlls00001.o │ │ │ │ │ __imp_WakeByAddressAll in api-ms-win-core-synch-l1-2-0.dlls00001.o │ │ │ │ │ WaitOnAddress in api-ms-win-core-synch-l1-2-0.dlls00000.o │ │ │ │ │ __imp_WaitOnAddress in api-ms-win-core-synch-l1-2-0.dlls00000.o │ │ │ │ │ │ │ │ │ │ @@ -2361,89 +2361,89 @@ │ │ │ │ │ bcryptprimitives.dllt.o: │ │ │ │ │ 0000000000000000 b .bss │ │ │ │ │ 0000000000000000 d .data │ │ │ │ │ 0000000000000000 i .idata$4 │ │ │ │ │ 0000000000000000 i .idata$5 │ │ │ │ │ 0000000000000000 i .idata$7 │ │ │ │ │ 0000000000000000 t .text │ │ │ │ │ -0000000000000000 I ___tmp_rustcEEj9Ch_bcryptprimitives_lib_iname │ │ │ │ │ +0000000000000000 I ___tmp_rustcRtCTVS_bcryptprimitives_lib_iname │ │ │ │ │ │ │ │ │ │ bcryptprimitives.dllh.o: │ │ │ │ │ 0000000000000000 b .bss │ │ │ │ │ 0000000000000000 d .data │ │ │ │ │ 0000000000000000 i .idata$2 │ │ │ │ │ 0000000000000000 i .idata$4 │ │ │ │ │ 0000000000000000 i .idata$5 │ │ │ │ │ 0000000000000000 t .text │ │ │ │ │ - U ___tmp_rustcEEj9Ch_bcryptprimitives_lib_iname │ │ │ │ │ -0000000000000000 I _head__tmp_rustcEEj9Ch_bcryptprimitives_lib │ │ │ │ │ + U ___tmp_rustcRtCTVS_bcryptprimitives_lib_iname │ │ │ │ │ +0000000000000000 I _head__tmp_rustcRtCTVS_bcryptprimitives_lib │ │ │ │ │ 0000000000000000 i fthunk │ │ │ │ │ 0000000000000000 i hname │ │ │ │ │ │ │ │ │ │ bcryptprimitives.dlls00000.o: │ │ │ │ │ 0000000000000000 b .bss │ │ │ │ │ 0000000000000000 d .data │ │ │ │ │ 0000000000000000 i .idata$4 │ │ │ │ │ 0000000000000000 i .idata$5 │ │ │ │ │ 0000000000000000 i .idata$6 │ │ │ │ │ 0000000000000000 i .idata$7 │ │ │ │ │ 0000000000000000 t .text │ │ │ │ │ 0000000000000000 T ProcessPrng │ │ │ │ │ 0000000000000000 I __imp_ProcessPrng │ │ │ │ │ - U _head__tmp_rustcEEj9Ch_bcryptprimitives_lib │ │ │ │ │ + U _head__tmp_rustcRtCTVS_bcryptprimitives_lib │ │ │ │ │ │ │ │ │ │ api-ms-win-core-synch-l1-2-0.dllt.o: │ │ │ │ │ 0000000000000000 b .bss │ │ │ │ │ 0000000000000000 d .data │ │ │ │ │ 0000000000000000 i .idata$4 │ │ │ │ │ 0000000000000000 i .idata$5 │ │ │ │ │ 0000000000000000 i .idata$7 │ │ │ │ │ 0000000000000000 t .text │ │ │ │ │ -0000000000000000 I ___tmp_rustcEEj9Ch_api_ms_win_core_synch_l1_2_0_lib_iname │ │ │ │ │ +0000000000000000 I ___tmp_rustcRtCTVS_api_ms_win_core_synch_l1_2_0_lib_iname │ │ │ │ │ │ │ │ │ │ api-ms-win-core-synch-l1-2-0.dllh.o: │ │ │ │ │ 0000000000000000 b .bss │ │ │ │ │ 0000000000000000 d .data │ │ │ │ │ 0000000000000000 i .idata$2 │ │ │ │ │ 0000000000000000 i .idata$4 │ │ │ │ │ 0000000000000000 i .idata$5 │ │ │ │ │ 0000000000000000 t .text │ │ │ │ │ - U ___tmp_rustcEEj9Ch_api_ms_win_core_synch_l1_2_0_lib_iname │ │ │ │ │ -0000000000000000 I _head__tmp_rustcEEj9Ch_api_ms_win_core_synch_l1_2_0_lib │ │ │ │ │ + U ___tmp_rustcRtCTVS_api_ms_win_core_synch_l1_2_0_lib_iname │ │ │ │ │ +0000000000000000 I _head__tmp_rustcRtCTVS_api_ms_win_core_synch_l1_2_0_lib │ │ │ │ │ 0000000000000000 i fthunk │ │ │ │ │ 0000000000000000 i hname │ │ │ │ │ │ │ │ │ │ api-ms-win-core-synch-l1-2-0.dlls00002.o: │ │ │ │ │ 0000000000000000 b .bss │ │ │ │ │ 0000000000000000 d .data │ │ │ │ │ 0000000000000000 i .idata$4 │ │ │ │ │ 0000000000000000 i .idata$5 │ │ │ │ │ 0000000000000000 i .idata$6 │ │ │ │ │ 0000000000000000 i .idata$7 │ │ │ │ │ 0000000000000000 t .text │ │ │ │ │ 0000000000000000 T WakeByAddressSingle │ │ │ │ │ 0000000000000000 I __imp_WakeByAddressSingle │ │ │ │ │ - U _head__tmp_rustcEEj9Ch_api_ms_win_core_synch_l1_2_0_lib │ │ │ │ │ + U _head__tmp_rustcRtCTVS_api_ms_win_core_synch_l1_2_0_lib │ │ │ │ │ │ │ │ │ │ api-ms-win-core-synch-l1-2-0.dlls00001.o: │ │ │ │ │ 0000000000000000 b .bss │ │ │ │ │ 0000000000000000 d .data │ │ │ │ │ 0000000000000000 i .idata$4 │ │ │ │ │ 0000000000000000 i .idata$5 │ │ │ │ │ 0000000000000000 i .idata$6 │ │ │ │ │ 0000000000000000 i .idata$7 │ │ │ │ │ 0000000000000000 t .text │ │ │ │ │ 0000000000000000 T WakeByAddressAll │ │ │ │ │ 0000000000000000 I __imp_WakeByAddressAll │ │ │ │ │ - U _head__tmp_rustcEEj9Ch_api_ms_win_core_synch_l1_2_0_lib │ │ │ │ │ + U _head__tmp_rustcRtCTVS_api_ms_win_core_synch_l1_2_0_lib │ │ │ │ │ │ │ │ │ │ api-ms-win-core-synch-l1-2-0.dlls00000.o: │ │ │ │ │ 0000000000000000 b .bss │ │ │ │ │ 0000000000000000 d .data │ │ │ │ │ 0000000000000000 i .idata$4 │ │ │ │ │ 0000000000000000 i .idata$5 │ │ │ │ │ 0000000000000000 i .idata$6 │ │ │ │ │ 0000000000000000 i .idata$7 │ │ │ │ │ 0000000000000000 t .text │ │ │ │ │ 0000000000000000 T WaitOnAddress │ │ │ │ │ 0000000000000000 I __imp_WaitOnAddress │ │ │ │ │ - U _head__tmp_rustcEEj9Ch_api_ms_win_core_synch_l1_2_0_lib │ │ │ │ │ + U _head__tmp_rustcRtCTVS_api_ms_win_core_synch_l1_2_0_lib │ │ │ │ ├── bcryptprimitives.dllt.o │ │ │ │ │ @@ -30,10 +30,10 @@ │ │ │ │ │ 000001d0: 0000 0000 0000 0000 0000 0000 0000 0000 ................ │ │ │ │ │ 000001e0: 2e69 6461 7461 2435 0000 0000 0500 0000 .idata$5........ │ │ │ │ │ 000001f0: 0301 0800 0000 0000 0000 0000 0000 0000 ................ │ │ │ │ │ 00000200: 0000 0000 2e69 6461 7461 2437 0000 0000 .....idata$7.... │ │ │ │ │ 00000210: 0600 0000 0301 1500 0000 0000 0000 0000 ................ │ │ │ │ │ 00000220: 0000 0000 0000 0000 0000 0000 0400 0000 ................ │ │ │ │ │ 00000230: 0000 0000 0600 0000 0200 3200 0000 5f5f ..........2...__ │ │ │ │ │ -00000240: 5f74 6d70 5f72 7573 7463 4545 6a39 4368 _tmp_rustcEEj9Ch │ │ │ │ │ +00000240: 5f74 6d70 5f72 7573 7463 5274 4354 5653 _tmp_rustcRtCTVS │ │ │ │ │ 00000250: 5f62 6372 7970 7470 7269 6d69 7469 7665 _bcryptprimitive │ │ │ │ │ 00000260: 735f 6c69 625f 696e 616d 6500 s_lib_iname. │ │ │ │ ├── bcryptprimitives.dllh.o │ │ │ │ │ @@ -32,13 +32,13 @@ │ │ │ │ │ 000001f0: 2432 0000 0000 0400 0000 0301 1400 0000 $2.............. │ │ │ │ │ 00000200: 0300 0000 0000 0000 0000 0000 0000 2e69 ...............i │ │ │ │ │ 00000210: 6461 7461 2434 0000 0000 0600 0000 0300 data$4.......... │ │ │ │ │ 00000220: 2e69 6461 7461 2435 0000 0000 0500 0000 .idata$5........ │ │ │ │ │ 00000230: 0300 0000 0000 0400 0000 0000 0000 0400 ................ │ │ │ │ │ 00000240: 0000 0200 0000 0000 3000 0000 0000 0000 ........0....... │ │ │ │ │ 00000250: 0000 0000 0200 5e00 0000 5f68 6561 645f ......^..._head_ │ │ │ │ │ -00000260: 5f74 6d70 5f72 7573 7463 4545 6a39 4368 _tmp_rustcEEj9Ch │ │ │ │ │ +00000260: 5f74 6d70 5f72 7573 7463 5274 4354 5653 _tmp_rustcRtCTVS │ │ │ │ │ 00000270: 5f62 6372 7970 7470 7269 6d69 7469 7665 _bcryptprimitive │ │ │ │ │ 00000280: 735f 6c69 6200 5f5f 5f74 6d70 5f72 7573 s_lib.___tmp_rus │ │ │ │ │ -00000290: 7463 4545 6a39 4368 5f62 6372 7970 7470 tcEEj9Ch_bcryptp │ │ │ │ │ +00000290: 7463 5274 4354 5653 5f62 6372 7970 7470 tcRtCTVS_bcryptp │ │ │ │ │ 000002a0: 7269 6d69 7469 7665 735f 6c69 625f 696e rimitives_lib_in │ │ │ │ │ 000002b0: 616d 6500 ame. │ │ │ │ ├── bcryptprimitives.dlls00000.o │ │ │ │ │ @@ -32,10 +32,10 @@ │ │ │ │ │ 000001f0: 7461 2436 0000 0000 0700 0000 0300 0000 ta$6............ │ │ │ │ │ 00000200: 0000 0400 0000 0000 0000 0100 0000 0200 ................ │ │ │ │ │ 00000210: 0000 0000 1000 0000 0000 0000 0500 0000 ................ │ │ │ │ │ 00000220: 0200 0000 0000 2200 0000 0000 0000 0000 ......"......... │ │ │ │ │ 00000230: 0000 0200 4e00 0000 5072 6f63 6573 7350 ....N...ProcessP │ │ │ │ │ 00000240: 726e 6700 5f5f 696d 705f 5072 6f63 6573 rng.__imp_Proces │ │ │ │ │ 00000250: 7350 726e 6700 5f68 6561 645f 5f74 6d70 sPrng._head__tmp │ │ │ │ │ -00000260: 5f72 7573 7463 4545 6a39 4368 5f62 6372 _rustcEEj9Ch_bcr │ │ │ │ │ +00000260: 5f72 7573 7463 5274 4354 5653 5f62 6372 _rustcRtCTVS_bcr │ │ │ │ │ 00000270: 7970 7470 7269 6d69 7469 7665 735f 6c69 yptprimitives_li │ │ │ │ │ 00000280: 6200 b. │ │ │ │ ├── api-ms-win-core-synch-l1-2-0.dllt.o │ │ │ │ │ @@ -31,11 +31,11 @@ │ │ │ │ │ 000001e0: 0000 0000 0000 0000 0000 0000 2e69 6461 .............ida │ │ │ │ │ 000001f0: 7461 2435 0000 0000 0500 0000 0301 0800 ta$5............ │ │ │ │ │ 00000200: 0000 0000 0000 0000 0000 0000 0000 0000 ................ │ │ │ │ │ 00000210: 2e69 6461 7461 2437 0000 0000 0600 0000 .idata$7........ │ │ │ │ │ 00000220: 0301 2100 0000 0000 0000 0000 0000 0000 ..!............. │ │ │ │ │ 00000230: 0000 0000 0000 0000 0400 0000 0000 0000 ................ │ │ │ │ │ 00000240: 0600 0000 0200 3e00 0000 5f5f 5f74 6d70 ......>...___tmp │ │ │ │ │ -00000250: 5f72 7573 7463 4545 6a39 4368 5f61 7069 _rustcEEj9Ch_api │ │ │ │ │ +00000250: 5f72 7573 7463 5274 4354 5653 5f61 7069 _rustcRtCTVS_api │ │ │ │ │ 00000260: 5f6d 735f 7769 6e5f 636f 7265 5f73 796e _ms_win_core_syn │ │ │ │ │ 00000270: 6368 5f6c 315f 325f 305f 6c69 625f 696e ch_l1_2_0_lib_in │ │ │ │ │ 00000280: 616d 6500 ame. │ │ │ │ ├── api-ms-win-core-synch-l1-2-0.dllh.o │ │ │ │ │ @@ -32,14 +32,14 @@ │ │ │ │ │ 000001f0: 2432 0000 0000 0400 0000 0301 1400 0000 $2.............. │ │ │ │ │ 00000200: 0300 0000 0000 0000 0000 0000 0000 2e69 ...............i │ │ │ │ │ 00000210: 6461 7461 2434 0000 0000 0600 0000 0300 data$4.......... │ │ │ │ │ 00000220: 2e69 6461 7461 2435 0000 0000 0500 0000 .idata$5........ │ │ │ │ │ 00000230: 0300 0000 0000 0400 0000 0000 0000 0400 ................ │ │ │ │ │ 00000240: 0000 0200 0000 0000 3c00 0000 0000 0000 ........<....... │ │ │ │ │ 00000250: 0000 0000 0200 7600 0000 5f68 6561 645f ......v..._head_ │ │ │ │ │ -00000260: 5f74 6d70 5f72 7573 7463 4545 6a39 4368 _tmp_rustcEEj9Ch │ │ │ │ │ +00000260: 5f74 6d70 5f72 7573 7463 5274 4354 5653 _tmp_rustcRtCTVS │ │ │ │ │ 00000270: 5f61 7069 5f6d 735f 7769 6e5f 636f 7265 _api_ms_win_core │ │ │ │ │ 00000280: 5f73 796e 6368 5f6c 315f 325f 305f 6c69 _synch_l1_2_0_li │ │ │ │ │ -00000290: 6200 5f5f 5f74 6d70 5f72 7573 7463 4545 b.___tmp_rustcEE │ │ │ │ │ -000002a0: 6a39 4368 5f61 7069 5f6d 735f 7769 6e5f j9Ch_api_ms_win_ │ │ │ │ │ +00000290: 6200 5f5f 5f74 6d70 5f72 7573 7463 5274 b.___tmp_rustcRt │ │ │ │ │ +000002a0: 4354 5653 5f61 7069 5f6d 735f 7769 6e5f CTVS_api_ms_win_ │ │ │ │ │ 000002b0: 636f 7265 5f73 796e 6368 5f6c 315f 325f core_synch_l1_2_ │ │ │ │ │ 000002c0: 305f 6c69 625f 696e 616d 6500 0_lib_iname. │ │ │ │ ├── api-ms-win-core-synch-l1-2-0.dlls00002.o │ │ │ │ │ @@ -33,11 +33,11 @@ │ │ │ │ │ 00000200: 0700 0000 0300 0000 0000 0400 0000 0000 ................ │ │ │ │ │ 00000210: 0000 0100 0000 0200 0000 0000 1800 0000 ................ │ │ │ │ │ 00000220: 0000 0000 0500 0000 0200 0000 0000 3200 ..............2. │ │ │ │ │ 00000230: 0000 0000 0000 0000 0000 0200 6a00 0000 ............j... │ │ │ │ │ 00000240: 5761 6b65 4279 4164 6472 6573 7353 696e WakeByAddressSin │ │ │ │ │ 00000250: 676c 6500 5f5f 696d 705f 5761 6b65 4279 gle.__imp_WakeBy │ │ │ │ │ 00000260: 4164 6472 6573 7353 696e 676c 6500 5f68 AddressSingle._h │ │ │ │ │ -00000270: 6561 645f 5f74 6d70 5f72 7573 7463 4545 ead__tmp_rustcEE │ │ │ │ │ -00000280: 6a39 4368 5f61 7069 5f6d 735f 7769 6e5f j9Ch_api_ms_win_ │ │ │ │ │ +00000270: 6561 645f 5f74 6d70 5f72 7573 7463 5274 ead__tmp_rustcRt │ │ │ │ │ +00000280: 4354 5653 5f61 7069 5f6d 735f 7769 6e5f CTVS_api_ms_win_ │ │ │ │ │ 00000290: 636f 7265 5f73 796e 6368 5f6c 315f 325f core_synch_l1_2_ │ │ │ │ │ 000002a0: 305f 6c69 6200 0_lib. │ │ │ │ ├── api-ms-win-core-synch-l1-2-0.dlls00001.o │ │ │ │ │ @@ -33,10 +33,10 @@ │ │ │ │ │ 00000200: 0300 0000 0000 0400 0000 0000 0000 0100 ................ │ │ │ │ │ 00000210: 0000 0200 0000 0000 1500 0000 0000 0000 ................ │ │ │ │ │ 00000220: 0500 0000 0200 0000 0000 2c00 0000 0000 ..........,..... │ │ │ │ │ 00000230: 0000 0000 0000 0200 6400 0000 5761 6b65 ........d...Wake │ │ │ │ │ 00000240: 4279 4164 6472 6573 7341 6c6c 005f 5f69 ByAddressAll.__i │ │ │ │ │ 00000250: 6d70 5f57 616b 6542 7941 6464 7265 7373 mp_WakeByAddress │ │ │ │ │ 00000260: 416c 6c00 5f68 6561 645f 5f74 6d70 5f72 All._head__tmp_r │ │ │ │ │ -00000270: 7573 7463 4545 6a39 4368 5f61 7069 5f6d ustcEEj9Ch_api_m │ │ │ │ │ +00000270: 7573 7463 5274 4354 5653 5f61 7069 5f6d ustcRtCTVS_api_m │ │ │ │ │ 00000280: 735f 7769 6e5f 636f 7265 5f73 796e 6368 s_win_core_synch │ │ │ │ │ 00000290: 5f6c 315f 325f 305f 6c69 6200 _l1_2_0_lib. │ │ │ │ ├── api-ms-win-core-synch-l1-2-0.dlls00000.o │ │ │ │ │ @@ -32,11 +32,11 @@ │ │ │ │ │ 000001f0: 7461 2436 0000 0000 0700 0000 0300 0000 ta$6............ │ │ │ │ │ 00000200: 0000 0400 0000 0000 0000 0100 0000 0200 ................ │ │ │ │ │ 00000210: 0000 0000 1200 0000 0000 0000 0500 0000 ................ │ │ │ │ │ 00000220: 0200 0000 0000 2600 0000 0000 0000 0000 ......&......... │ │ │ │ │ 00000230: 0000 0200 5e00 0000 5761 6974 4f6e 4164 ....^...WaitOnAd │ │ │ │ │ 00000240: 6472 6573 7300 5f5f 696d 705f 5761 6974 dress.__imp_Wait │ │ │ │ │ 00000250: 4f6e 4164 6472 6573 7300 5f68 6561 645f OnAddress._head_ │ │ │ │ │ -00000260: 5f74 6d70 5f72 7573 7463 4545 6a39 4368 _tmp_rustcEEj9Ch │ │ │ │ │ +00000260: 5f74 6d70 5f72 7573 7463 5274 4354 5653 _tmp_rustcRtCTVS │ │ │ │ │ 00000270: 5f61 7069 5f6d 735f 7769 6e5f 636f 7265 _api_ms_win_core │ │ │ │ │ 00000280: 5f73 796e 6368 5f6c 315f 325f 305f 6c69 _synch_l1_2_0_li │ │ │ │ │ 00000290: 6200 b. │ │ │ ├── ./usr/lib/rustlib/x86_64-pc-windows-gnu/lib/std-77bb723fc58ce3d1.dll │ │ │ │ ├── objdump │ │ │ │ │ @@ -26,15 +26,15 @@ │ │ │ │ │ MajorImageVersion 0 │ │ │ │ │ MinorImageVersion 0 │ │ │ │ │ MajorSubsystemVersion 5 │ │ │ │ │ MinorSubsystemVersion 2 │ │ │ │ │ Win32Version 00000000 │ │ │ │ │ SizeOfImage 01798000 │ │ │ │ │ SizeOfHeaders 00000600 │ │ │ │ │ -CheckSum 0182e0bb │ │ │ │ │ +CheckSum 0182a430 │ │ │ │ │ Subsystem 00000003 (Windows CUI) │ │ │ │ │ DllCharacteristics 00000160 │ │ │ │ │ HIGH_ENTROPY_VA │ │ │ │ │ DYNAMIC_BASE │ │ │ │ │ NX_COMPAT │ │ │ │ │ SizeOfStackReserve 0000000000200000 │ │ │ │ │ SizeOfStackCommit 0000000000001000 │ │ │ │ │ @@ -36599,507 +36599,507 @@ │ │ │ │ │ [12255](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000740 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.118.llvm.13665133684747362110 │ │ │ │ │ [12256](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000938 __imp_SetWaitableTimer │ │ │ │ │ [12257](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000318 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.13.llvm.9587153679006429619 │ │ │ │ │ [12258](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000036e8 anon.941f0f04b36aa440174d89d326747b6f.10.llvm.16620058351426711825 │ │ │ │ │ [12259](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a410 GetProcAddress │ │ │ │ │ [12260](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000820 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.84.llvm.9180192027238945235 │ │ │ │ │ [12261](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a20 __imp_memcpy │ │ │ │ │ -[12262](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000046f2 anon.ce6f0c62864fa439afba1682d1475d3d.118.llvm.14048921605721191922 │ │ │ │ │ -[12263](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000218 __imp_anon.577344e6c4a90a10ff600a929dedcba7.3.llvm.11685822864145163790 │ │ │ │ │ -[12264](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006d0 __imp_CreateSymbolicLinkW │ │ │ │ │ -[12265](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a570 CompareStringOrdinal │ │ │ │ │ -[12266](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000069e0 anon.5188eecf01c48ed8fcadadd01fcebeeb.1.llvm.10386673973210777259 │ │ │ │ │ -[12267](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2370 memmove │ │ │ │ │ -[12268](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000026d0 anon.2d4ed69d03b8b00b295e2865b118c80a.1.llvm.9587153679006429619 │ │ │ │ │ -[12269](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a528 CreateSymbolicLinkW │ │ │ │ │ -[12270](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e50 anon.ce6f0c62864fa439afba1682d1475d3d.20.llvm.14048921605721191922 │ │ │ │ │ -[12271](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004a50 anon.a43af9cc4981a42dd00b013f8f55f130.49.llvm.13665133684747362110 │ │ │ │ │ -[12272](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013198 anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.7.llvm.12700038450165258506 │ │ │ │ │ -[12273](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000e0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.27.llvm.12196597439006139751 │ │ │ │ │ -[12274](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000398 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.55.llvm.65172163764165323 │ │ │ │ │ -[12275](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000c0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.24.llvm.12196597439006139751 │ │ │ │ │ -[12276](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004260 anon.ce6f0c62864fa439afba1682d1475d3d.63.llvm.14048921605721191922 │ │ │ │ │ -[12277](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007a8 __imp_GetFileInformationByHandle │ │ │ │ │ -[12278](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000148 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.9.llvm.10021583357862909 │ │ │ │ │ -[12279](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __rt_psrelocs_size │ │ │ │ │ -[12280](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b88 __imp_anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.3.llvm.12700038450165258506 │ │ │ │ │ -[12281](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000021270 anon.d5fd6146a7cb5ea87f639cab18b2a05b.42.llvm.3779847476987057767 │ │ │ │ │ -[12282](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2c0 TerminateProcess │ │ │ │ │ -[12283](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002e26 anon.edf9b0bdfd963b6a2ea99216811efd5e.54.llvm.65172163764165323 │ │ │ │ │ -[12284](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e80 __imp_anon.d5fd6146a7cb5ea87f639cab18b2a05b.42.llvm.3779847476987057767 │ │ │ │ │ -[12285](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c3148 strncmp │ │ │ │ │ -[12286](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a668 WSARecv │ │ │ │ │ -[12287](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b70 __imp_anon.7ec0d7d1b51f482853d19890eaa43e99.14.llvm.4855701895496871646 │ │ │ │ │ -[12288](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000750 __imp_FreeEnvironmentStringsW │ │ │ │ │ -[12289](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2160 WaitOnAddress │ │ │ │ │ -[12290](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000898 __imp_MoveFileExW │ │ │ │ │ -[12291](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000078 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.1.llvm.12196597439006139751 │ │ │ │ │ -[12292](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022bd0 .refptr.__mingw_app_type │ │ │ │ │ -[12293](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5f0 recv │ │ │ │ │ -[12294](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000538 __imp__ZN3std10sys_common6thread9min_stack3MIN17hd6c24a62017ef65aE.0.llvm.14048921605721191922 │ │ │ │ │ -[12295](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006228 anon.2fc0b598515d6d45a6f7a748d37f9e68.93.llvm.9180192027238945235 │ │ │ │ │ -[12296](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ac8 __imp_anon.75cd115d168aa5adc70873d7be22c67a.12.llvm.8768119154728042530 │ │ │ │ │ -[12297](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000eb0 __imp__execute_onexit_table │ │ │ │ │ -[12298](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007eb3 anon.75cd115d168aa5adc70873d7be22c67a.9.llvm.8768119154728042530 │ │ │ │ │ -[12299](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000898 _ZN3std3sys3pal7windows1c13GetTempPath2W3PTR17he23b5a39201cf65cE │ │ │ │ │ -[12300](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000046ea anon.ce6f0c62864fa439afba1682d1475d3d.117.llvm.14048921605721191922 │ │ │ │ │ -[12301](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000970 __imp_TlsGetValue │ │ │ │ │ -[12302](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a508 DeleteFileW │ │ │ │ │ -[12303](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c98 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.39.llvm.10283439849247210698 │ │ │ │ │ -[12304](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000640 __imp_WaitOnAddress │ │ │ │ │ -[12305](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001e98 anon.577344e6c4a90a10ff600a929dedcba7.5.llvm.11685822864145163790 │ │ │ │ │ -[12306](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000758 __imp_GetCommandLineW │ │ │ │ │ -[12307](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c21b8 _Unwind_DeleteException │ │ │ │ │ -[12308](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a488 GetCurrentThread │ │ │ │ │ -[12309](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004895 anon.a43af9cc4981a42dd00b013f8f55f130.18.llvm.13665133684747362110 │ │ │ │ │ -[12310](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d89 anon.2611162d579b3e706d0c0f15accb8ea6.3.llvm.17987727548992354187 │ │ │ │ │ -[12311](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a88 __imp_anon.e2378e14a3ab6920970de912c40858fb.1.llvm.12155384279649763508 │ │ │ │ │ -[12312](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015131 anon.7a6259c55b9abecd4a2eb0873fc8b779.47.llvm.10283439849247210698 │ │ │ │ │ -[12313](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000858 __imp_InitOnceBeginInitialize │ │ │ │ │ -[12314](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000eb8 __imp__register_onexit_function │ │ │ │ │ -[12315](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006a20 anon.5188eecf01c48ed8fcadadd01fcebeeb.2.llvm.10386673973210777259 │ │ │ │ │ -[12316](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008c0 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.3.llvm.4036729494550109879 │ │ │ │ │ -[12317](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006168 anon.2fc0b598515d6d45a6f7a748d37f9e68.87.llvm.9180192027238945235 │ │ │ │ │ -[12318](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2a8 TlsGetValue │ │ │ │ │ -[12319](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000150 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.10.llvm.10021583357862909 │ │ │ │ │ -[12320](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a80 __imp_anon.b600da5f5c44c0dd2674915485b1c9f6.0.llvm.9103046057031032332 │ │ │ │ │ -[12321](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000173a0 anon.df4f5fc91c1c1e84f2976758feaea474.21.llvm.17095335174290335670 │ │ │ │ │ -[12322](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c2330 _amsg_exit │ │ │ │ │ -[12323](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013d20 _ZN4core3num7flt2dec8strategy5grisu12CACHED_POW1017hc29b3bf8237d228dE │ │ │ │ │ -[12324](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000160 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.13.llvm.10021583357862909 │ │ │ │ │ -[12325](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2d0 SleepEx │ │ │ │ │ -[12326](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001510c anon.7a6259c55b9abecd4a2eb0873fc8b779.32.llvm.10283439849247210698 │ │ │ │ │ -[12327](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002540 anon.577344e6c4a90a10ff600a929dedcba7.81.llvm.11685822864145163790 │ │ │ │ │ -[12328](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005b70 anon.2fc0b598515d6d45a6f7a748d37f9e68.44.llvm.9180192027238945235 │ │ │ │ │ -[12329](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000020 _ZN3std5panic14SHOULD_CAPTURE17h47fa1dca84a94988E.0.llvm.12196597439006139751 │ │ │ │ │ -[12330](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015130 anon.7a6259c55b9abecd4a2eb0873fc8b779.46.llvm.10283439849247210698 │ │ │ │ │ -[12331](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000138c8 anon.9de54bf691a285dd20d4e87e6b508fbd.4.llvm.12123695082059135366 │ │ │ │ │ -[12332](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000790 __imp_GetEnvironmentVariableW │ │ │ │ │ -[12333](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d38 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.72.llvm.10283439849247210698 │ │ │ │ │ -[12334](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002880 anon.2d4ed69d03b8b00b295e2865b118c80a.15.llvm.9587153679006429619 │ │ │ │ │ -[12335](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ee4 __native_dllmain_reason │ │ │ │ │ -[12336](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003b85 anon.941f0f04b36aa440174d89d326747b6f.54.llvm.16620058351426711825 │ │ │ │ │ -[12337](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005578 anon.71b4c3b3c7c90ed67c6b8e618b4d496a.1.llvm.14138378158770856212 │ │ │ │ │ -[12338](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000890 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.101.llvm.9180192027238945235 │ │ │ │ │ -[12339](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013938 anon.9de54bf691a285dd20d4e87e6b508fbd.7.llvm.12123695082059135366 │ │ │ │ │ -[12340](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005b88 anon.2fc0b598515d6d45a6f7a748d37f9e68.45.llvm.9180192027238945235 │ │ │ │ │ -[12341](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009f8 anon.c5e06b7d2fb27e4271afbca860883ce8.2.llvm.12196597439006139751 │ │ │ │ │ -[12342](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000770 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.4.llvm.9180192027238945235 │ │ │ │ │ -[12343](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000050 __imp_anon.08c341bb7f186daefc16bdd18254cc9c.4.llvm.2852608270795916942 │ │ │ │ │ -[12344](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000950 __imp_SwitchToThread │ │ │ │ │ -[12345](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d20 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.69.llvm.10283439849247210698 │ │ │ │ │ -[12346](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000940 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.41.llvm.4036729494550109879 │ │ │ │ │ -[12347](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006a8 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.18.llvm.13665133684747362110 │ │ │ │ │ -[12348](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000660 __imp_ProcessPrng │ │ │ │ │ -[12349](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a278 WideCharToMultiByte │ │ │ │ │ -[12350](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001a10 __lib64_libmsvcrt_def_a_iname │ │ │ │ │ -[12351](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015ef0 anon.8d718ed12c404e6593cdb19a2e5276ea.6.llvm.819651363561423643 │ │ │ │ │ -[12352](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008e0 __imp_RtlLookupFunctionEntry │ │ │ │ │ -[12353](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000dd8 __imp_anon.07b55acb663eb35d742bae824872f75e.9.llvm.58757282566773765 │ │ │ │ │ -[12354](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006f8 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.58.llvm.13665133684747362110 │ │ │ │ │ -[12355](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000810 __imp_GetStdHandle │ │ │ │ │ -[12356](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004e0 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.17.llvm.14048921605721191922 │ │ │ │ │ -[12357](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e88 anon.ce6f0c62864fa439afba1682d1475d3d.22.llvm.14048921605721191922 │ │ │ │ │ -[12358](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006f88 anon.5188eecf01c48ed8fcadadd01fcebeeb.51.llvm.10386673973210777259 │ │ │ │ │ -[12359](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a430 GetModuleFileNameW │ │ │ │ │ -[12360](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a420 GetModuleHandleW │ │ │ │ │ -[12361](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a428 GetModuleHandleA │ │ │ │ │ -[12362](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000188 _ZN3std9panicking11panic_count17LOCAL_PANIC_COUNT7__getit5__KEY17h6b4730867b4d8da1E.llvm.11685822864145163790 │ │ │ │ │ -[12363](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000135d0 _ZN4core3fmt3num14DEC_DIGITS_LUT17h038d33b26edcbfd2E │ │ │ │ │ -[12364](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000900 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.31.llvm.4036729494550109879 │ │ │ │ │ -[12365](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a500 DeleteProcThreadAttributeList │ │ │ │ │ -[12366](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008d0 __imp_RemoveDirectoryW │ │ │ │ │ -[12367](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bf8 __imp_anon.bb01d4b423a85a795a1692e8cd9c64e5.10.llvm.11285312269184381906 │ │ │ │ │ -[12368](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e48 __imp_anon.07b55acb663eb35d742bae824872f75e.30.llvm.58757282566773765 │ │ │ │ │ -[12369](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a30 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.71.llvm.10386673973210777259 │ │ │ │ │ -[12370](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b98 __imp_anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.6.llvm.12700038450165258506 │ │ │ │ │ -[12371](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a60 __imp_NtCreateFile │ │ │ │ │ -[12372](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ea8 __imp_anon.d5fd6146a7cb5ea87f639cab18b2a05b.47.llvm.3779847476987057767 │ │ │ │ │ -[12373](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c20 .refptr.__xc_a │ │ │ │ │ -[12374](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000690 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.15.llvm.13665133684747362110 │ │ │ │ │ -[12375](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022b70 .refptr._ZN3std9panicking11panic_count18GLOBAL_PANIC_COUNT17h5b40b3f81b5486b3E │ │ │ │ │ -[12376](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c38 __imp_anon.1cd6cbb5d23cd003f709872fa6a8a6dd.8.llvm.9517595369394268439 │ │ │ │ │ -[12377](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000026f8 anon.2d4ed69d03b8b00b295e2865b118c80a.2.llvm.9587153679006429619 │ │ │ │ │ -[12378](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000098 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.8.llvm.12196597439006139751 │ │ │ │ │ -[12379](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e10 anon.ce6f0c62864fa439afba1682d1475d3d.17.llvm.14048921605721191922 │ │ │ │ │ -[12380](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003000 anon.edf9b0bdfd963b6a2ea99216811efd5e.77.llvm.65172163764165323 │ │ │ │ │ -[12381](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a370 QueryPerformanceCounter │ │ │ │ │ -[12382](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a580 CancelIo │ │ │ │ │ -[12383](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2158 WakeByAddressAll │ │ │ │ │ -[12384](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008a8 __imp_QueryPerformanceCounter │ │ │ │ │ -[12385](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000850 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.90.llvm.9180192027238945235 │ │ │ │ │ -[12386](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003820 anon.941f0f04b36aa440174d89d326747b6f.20.llvm.16620058351426711825 │ │ │ │ │ -[12387](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e20 __imp_anon.07b55acb663eb35d742bae824872f75e.25.llvm.58757282566773765 │ │ │ │ │ -[12388](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a598 NtWriteFile │ │ │ │ │ -[12389](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000528 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.63.llvm.14048921605721191922 │ │ │ │ │ -[12390](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000978 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.59.llvm.4036729494550109879 │ │ │ │ │ -[12391](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcd8 anon.07b55acb663eb35d742bae824872f75e.27.llvm.58757282566773765 │ │ │ │ │ -[12392](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009e8 __imp__lock │ │ │ │ │ -[12393](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000aa0 __imp_anon.75cd115d168aa5adc70873d7be22c67a.6.llvm.8768119154728042530 │ │ │ │ │ -[12394](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013900 str.0.llvm.12123695082059135366 │ │ │ │ │ -[12395](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c70 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.34.llvm.10283439849247210698 │ │ │ │ │ -[12396](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001868 anon.03a7b1eb39947173efb71e48c5b540f4.82.llvm.10021583357862909 │ │ │ │ │ -[12397](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d50 __imp_anon.8d718ed12c404e6593cdb19a2e5276ea.6.llvm.819651363561423643 │ │ │ │ │ -[12398](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000730 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.115.llvm.13665133684747362110 │ │ │ │ │ -[12399](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d98 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.16.llvm.17095335174290335670 │ │ │ │ │ -[12400](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000150 _ZN3std3sys3pal7windows4time12perf_counter9frequency9FREQUENCY17hb6767d30e4f028d6E.0.llvm.10386673973210777259 │ │ │ │ │ -[12401](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003d8 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.84.llvm.65172163764165323 │ │ │ │ │ -[12402](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006670 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.32.llvm.4036729494550109879 │ │ │ │ │ -[12403](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a480 GetEnvironmentStringsW │ │ │ │ │ -[12404](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000012948 anon.c4d194f4cabed4ef9246cda43331cffc.3.llvm.6008810897942320446 │ │ │ │ │ -[12405](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000180 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.83.llvm.10021583357862909 │ │ │ │ │ -[12406](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004c50 anon.a43af9cc4981a42dd00b013f8f55f130.65.llvm.13665133684747362110 │ │ │ │ │ -[12407](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b10 __imp_getsockopt │ │ │ │ │ -[12408](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000002138c anon.d5fd6146a7cb5ea87f639cab18b2a05b.44.llvm.3779847476987057767 │ │ │ │ │ -[12409](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c00 __imp_anon.9de54bf691a285dd20d4e87e6b508fbd.4.llvm.12123695082059135366 │ │ │ │ │ -[12410](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a548 CreateFileW │ │ │ │ │ -[12411](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e98 __imp_anon.d5fd6146a7cb5ea87f639cab18b2a05b.45.llvm.3779847476987057767 │ │ │ │ │ -[12412](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c21c0 _GCC_specific_handler │ │ │ │ │ -[12413](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000788 __imp_GetEnvironmentStringsW │ │ │ │ │ -[12414](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000068b8 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.59.llvm.4036729494550109879 │ │ │ │ │ -[12415](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007edb anon.75cd115d168aa5adc70873d7be22c67a.10.llvm.8768119154728042530 │ │ │ │ │ -[12416](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c3178 EnterCriticalSection │ │ │ │ │ -[12417](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cee anon.c5e06b7d2fb27e4271afbca860883ce8.28.llvm.12196597439006139751 │ │ │ │ │ -[12418](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004d8 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.0.llvm.14048921605721191922 │ │ │ │ │ -[12419](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006c8 __imp_CreateProcessW │ │ │ │ │ -[12420](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000060d0 anon.2fc0b598515d6d45a6f7a748d37f9e68.83.llvm.9180192027238945235 │ │ │ │ │ -[12421](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013160 anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.5.llvm.12700038450165258506 │ │ │ │ │ -[12422](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c3150 vfprintf │ │ │ │ │ -[12423](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d00 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.65.llvm.10283439849247210698 │ │ │ │ │ -[12424](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a550 CreateFileMappingA │ │ │ │ │ -[12425](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000440 __imp_anon.941f0f04b36aa440174d89d326747b6f.13.llvm.16620058351426711825 │ │ │ │ │ -[12426](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b78 __imp_anon.7ec0d7d1b51f482853d19890eaa43e99.15.llvm.4855701895496871646 │ │ │ │ │ -[12427](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000061e0 anon.2fc0b598515d6d45a6f7a748d37f9e68.90.llvm.9180192027238945235 │ │ │ │ │ -[12428](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000229c0 _tls_used │ │ │ │ │ -[12429](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000450 __imp_anon.941f0f04b36aa440174d89d326747b6f.20.llvm.16620058351426711825 │ │ │ │ │ -[12430](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000012930 anon.c4d194f4cabed4ef9246cda43331cffc.1.llvm.6008810897942320446 │ │ │ │ │ -[12431](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000158 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.11.llvm.10021583357862909 │ │ │ │ │ -[12432](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000048a2 anon.a43af9cc4981a42dd00b013f8f55f130.19.llvm.13665133684747362110 │ │ │ │ │ -[12433](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007469 anon.5188eecf01c48ed8fcadadd01fcebeeb.103.llvm.10386673973210777259 │ │ │ │ │ -[12434](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006f8 __imp_DeleteFileW │ │ │ │ │ -[12435](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000048dc anon.a43af9cc4981a42dd00b013f8f55f130.23.llvm.13665133684747362110 │ │ │ │ │ -[12436](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000da0 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.17.llvm.17095335174290335670 │ │ │ │ │ -[12437](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000328 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.15.llvm.9587153679006429619 │ │ │ │ │ -[12438](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000032a8 anon.edf9b0bdfd963b6a2ea99216811efd5e.116.llvm.65172163764165323 │ │ │ │ │ -[12439](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b58 __imp_shutdown │ │ │ │ │ -[12440](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b18 __imp_anon.567cec0599d353b04e33d4229b5f9b30.12.llvm.2628756017061842597 │ │ │ │ │ -[12441](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000180 __native_startup_lock │ │ │ │ │ -[12442](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002820 anon.2d4ed69d03b8b00b295e2865b118c80a.12.llvm.9587153679006429619 │ │ │ │ │ -[12443](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022ec0 __RUNTIME_PSEUDO_RELOC_LIST_END__ │ │ │ │ │ -[12444](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000028d0 anon.2d4ed69d03b8b00b295e2865b118c80a.17.llvm.9587153679006429619 │ │ │ │ │ -[12445](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000008 __xc_z │ │ │ │ │ -[12446](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007b0 __imp_GetFileInformationByHandleEx │ │ │ │ │ -[12447](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000030 __imp_anon.7ce35b53eeafc768de935b4fef3da959.12.llvm.1024159395525823541 │ │ │ │ │ -[12448](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a398 MapViewOfFile │ │ │ │ │ -[12449](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000017358 anon.df4f5fc91c1c1e84f2976758feaea474.19.llvm.17095335174290335670 │ │ │ │ │ -[12450](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006300 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.2.llvm.4036729494550109879 │ │ │ │ │ -[12451](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b20 __imp_listen │ │ │ │ │ -[12452](sec 11)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000010 ___tls_end__ │ │ │ │ │ -[12453](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003a58 anon.941f0f04b36aa440174d89d326747b6f.42.llvm.16620058351426711825 │ │ │ │ │ -[12454](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ba8 __imp__Unwind_Resume │ │ │ │ │ -[12455](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007f0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.42.llvm.9180192027238945235 │ │ │ │ │ -[12456](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000828 __imp_GetSystemTimePreciseAsFileTime │ │ │ │ │ -[12457](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015111 anon.7a6259c55b9abecd4a2eb0873fc8b779.34.llvm.10283439849247210698 │ │ │ │ │ -[12458](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000001e8 _ZN3std2io5stdio14OUTPUT_CAPTURE7__getit5__KEY17h4bf77338c012dfcbE.llvm.11685822864145163790 │ │ │ │ │ -[12459](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000110 __imp_anon.2611162d579b3e706d0c0f15accb8ea6.3.llvm.17987727548992354187 │ │ │ │ │ -[12460](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000050 ___crt_xp_start__ │ │ │ │ │ -[12461](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b68 __imp__GCC_specific_handler │ │ │ │ │ -[12462](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000918 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.34.llvm.4036729494550109879 │ │ │ │ │ -[12463](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015129 anon.7a6259c55b9abecd4a2eb0873fc8b779.41.llvm.10283439849247210698 │ │ │ │ │ -[12464](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000058f8 anon.2fc0b598515d6d45a6f7a748d37f9e68.20.llvm.9180192027238945235 │ │ │ │ │ -[12465](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008b8 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.2.llvm.4036729494550109879 │ │ │ │ │ -[12466](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000678 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.12.llvm.13665133684747362110 │ │ │ │ │ -[12467](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a280 WaitForSingleObject │ │ │ │ │ -[12468](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001248 anon.03a7b1eb39947173efb71e48c5b540f4.9.llvm.10021583357862909 │ │ │ │ │ -[12469](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015128 anon.7a6259c55b9abecd4a2eb0873fc8b779.40.llvm.10283439849247210698 │ │ │ │ │ -[12470](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a350 ReadFileEx │ │ │ │ │ -[12471](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000718 __imp__ZN3std9panicking4HOOK17h33440ca34cb79643E │ │ │ │ │ -[12472](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000d0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.26.llvm.12196597439006139751 │ │ │ │ │ -[12473](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a98 __imp_WSACleanup │ │ │ │ │ -[12474](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007a8 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.16.llvm.9180192027238945235 │ │ │ │ │ -[12475](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000170 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.52.llvm.10021583357862909 │ │ │ │ │ -[12476](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a610 getsockname │ │ │ │ │ -[12477](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000208f8 _ZN4core7unicode12unicode_data11white_space14WHITESPACE_MAP17h6da2769d9619e572E │ │ │ │ │ -[12478](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c30 .refptr.__xc_z │ │ │ │ │ -[12479](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dd38 anon.07b55acb663eb35d742bae824872f75e.30.llvm.58757282566773765 │ │ │ │ │ -[12480](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d18 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.68.llvm.10283439849247210698 │ │ │ │ │ -[12481](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000061c8 anon.2fc0b598515d6d45a6f7a748d37f9e68.89.llvm.9180192027238945235 │ │ │ │ │ -[12482](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000750 __imp_anon.71b4c3b3c7c90ed67c6b8e618b4d496a.0.llvm.14138378158770856212 │ │ │ │ │ -[12483](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008b0 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.1.llvm.4036729494550109879 │ │ │ │ │ -[12484](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a318 SetFileAttributesW │ │ │ │ │ -[12485](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000458 __imp_anon.941f0f04b36aa440174d89d326747b6f.27.llvm.16620058351426711825 │ │ │ │ │ -[12486](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d58 __imp_anon.8d718ed12c404e6593cdb19a2e5276ea.18.llvm.819651363561423643 │ │ │ │ │ -[12487](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010dd0 anon.567cec0599d353b04e33d4229b5f9b30.4.llvm.2628756017061842597 │ │ │ │ │ -[12488](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006d0 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.23.llvm.13665133684747362110 │ │ │ │ │ -[12489](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000074b0 anon.5188eecf01c48ed8fcadadd01fcebeeb.106.llvm.10386673973210777259 │ │ │ │ │ -[12490](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009a8 __imp_WaitForSingleObject │ │ │ │ │ -[12491](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000460 __imp_anon.941f0f04b36aa440174d89d326747b6f.28.llvm.16620058351426711825 │ │ │ │ │ -[12492](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a90 __imp_anon.5de116bb10f22f2f898f0999be20ad04.10.llvm.16857200617075268833 │ │ │ │ │ -[12493](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000048 __xl_z │ │ │ │ │ -[12494](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000002154e anon.d5fd6146a7cb5ea87f639cab18b2a05b.45.llvm.3779847476987057767 │ │ │ │ │ -[12495](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000960 __imp_TlsAlloc │ │ │ │ │ -[12496](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006a78 anon.5188eecf01c48ed8fcadadd01fcebeeb.4.llvm.10386673973210777259 │ │ │ │ │ -[12497](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005b30 anon.2fc0b598515d6d45a6f7a748d37f9e68.41.llvm.9180192027238945235 │ │ │ │ │ -[12498](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001a3c __lib64_libuserenv_a_iname │ │ │ │ │ -[12499](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004bd8 anon.a43af9cc4981a42dd00b013f8f55f130.58.llvm.13665133684747362110 │ │ │ │ │ -[12500](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000014 _head__tmp_rustcBv6EAf_bcryptprimitives_lib │ │ │ │ │ -[12501](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000980 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.65.llvm.4036729494550109879 │ │ │ │ │ -[12502](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000040e0 anon.ce6f0c62864fa439afba1682d1475d3d.49.llvm.14048921605721191922 │ │ │ │ │ -[12503](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008a0 _ZN3std3sys3pal7windows1c20SetThreadDescription3PTR17h62a2495fa6119c78E │ │ │ │ │ -[12504](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bc8 __imp_anon.3bd369ec61590d9272c591ac87029920.2.llvm.2123515186662715695 │ │ │ │ │ -[12505](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000738 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.117.llvm.13665133684747362110 │ │ │ │ │ -[12506](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c28 __imp_anon.9de54bf691a285dd20d4e87e6b508fbd.8.llvm.12123695082059135366 │ │ │ │ │ -[12507](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000080 anon.7ce35b53eeafc768de935b4fef3da959.3.llvm.1024159395525823541 │ │ │ │ │ -[12508](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000015c8 anon.03a7b1eb39947173efb71e48c5b540f4.52.llvm.10021583357862909 │ │ │ │ │ -[12509](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000038 __xl_c │ │ │ │ │ -[12510](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000e8 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.28.llvm.12196597439006139751 │ │ │ │ │ -[12511](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ec0 __imp__initialize_onexit_table │ │ │ │ │ -[12512](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009f8 __imp_abort │ │ │ │ │ -[12513](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000040 __xl_d │ │ │ │ │ -[12514](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000030b0 anon.edf9b0bdfd963b6a2ea99216811efd5e.85.llvm.65172163764165323 │ │ │ │ │ -[12515](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000029b0 anon.edf9b0bdfd963b6a2ea99216811efd5e.1.llvm.65172163764165323 │ │ │ │ │ -[12516](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003b80 anon.941f0f04b36aa440174d89d326747b6f.53.llvm.16620058351426711825 │ │ │ │ │ -[12517](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004ac0 anon.a43af9cc4981a42dd00b013f8f55f130.53.llvm.13665133684747362110 │ │ │ │ │ -[12518](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a678 WSADuplicateSocketW │ │ │ │ │ -[12519](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000029b0 anon.edf9b0bdfd963b6a2ea99216811efd5e.0.llvm.65172163764165323 │ │ │ │ │ -[12520](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002848 anon.2d4ed69d03b8b00b295e2865b118c80a.13.llvm.9587153679006429619 │ │ │ │ │ -[12521](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003980 anon.941f0f04b36aa440174d89d326747b6f.32.llvm.16620058351426711825 │ │ │ │ │ -[12522](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006bb8 anon.5188eecf01c48ed8fcadadd01fcebeeb.14.llvm.10386673973210777259 │ │ │ │ │ -[12523](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001ae4 libgcc_s_seh_1_dll_iname │ │ │ │ │ -[12524](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001384a anon.bb01d4b423a85a795a1692e8cd9c64e5.10.llvm.11285312269184381906 │ │ │ │ │ -[12525](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002280 anon.577344e6c4a90a10ff600a929dedcba7.53.llvm.11685822864145163790 │ │ │ │ │ -[12526](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000640 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.5.llvm.13665133684747362110 │ │ │ │ │ -[12527](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009b0 __imp_WideCharToMultiByte │ │ │ │ │ -[12528](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015118 anon.7a6259c55b9abecd4a2eb0873fc8b779.37.llvm.10283439849247210698 │ │ │ │ │ -[12529](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007f08 anon.75cd115d168aa5adc70873d7be22c67a.11.llvm.8768119154728042530 │ │ │ │ │ -[12530](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c31b8 ___DTOR_LIST__ │ │ │ │ │ -[12531](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a640 bind │ │ │ │ │ -[12532](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008e0 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.8.llvm.4036729494550109879 │ │ │ │ │ -[12533](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007c0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.19.llvm.9180192027238945235 │ │ │ │ │ -[12534](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006c00 anon.5188eecf01c48ed8fcadadd01fcebeeb.16.llvm.10386673973210777259 │ │ │ │ │ -[12535](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000028 __xl_a │ │ │ │ │ -[12536](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000a0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.9.llvm.12196597439006139751 │ │ │ │ │ -[12537](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000188 __native_startup_state │ │ │ │ │ -[12538](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a358 ReadFile │ │ │ │ │ -[12539](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b48 __imp_anon.c4d194f4cabed4ef9246cda43331cffc.4.llvm.6008810897942320446 │ │ │ │ │ -[12540](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000548 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.80.llvm.14048921605721191922 │ │ │ │ │ -[12541](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000698 __imp_CreateDirectoryW │ │ │ │ │ -[12542](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008a8 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.0.llvm.4036729494550109879 │ │ │ │ │ -[12543](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006c0 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.21.llvm.13665133684747362110 │ │ │ │ │ -[12544](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e58 __imp_anon.07b55acb663eb35d742bae824872f75e.32.llvm.58757282566773765 │ │ │ │ │ -[12545](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d30 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.71.llvm.10283439849247210698 │ │ │ │ │ -[12546](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000720 __imp_ExitProcess │ │ │ │ │ -[12547](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002588 anon.577344e6c4a90a10ff600a929dedcba7.83.llvm.11685822864145163790 │ │ │ │ │ -[12548](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ae0 __imp_anon.d13ef5d19e380ff1a25cb10df774bd92.2.llvm.13995198208019911955 │ │ │ │ │ -[12549](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001731d anon.df4f5fc91c1c1e84f2976758feaea474.17.llvm.17095335174290335670 │ │ │ │ │ -[12550](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000970 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.58.llvm.4036729494550109879 │ │ │ │ │ -[12551](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000e8 _ZN3std2rt7cleanup7CLEANUP17h07b9456e6b4bf964E.llvm.14048921605721191922 │ │ │ │ │ -[12552](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b18 __imp_ioctlsocket │ │ │ │ │ -[12553](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a418 GetOverlappedResult │ │ │ │ │ -[12554](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e00 __imp_anon.07b55acb663eb35d742bae824872f75e.21.llvm.58757282566773765 │ │ │ │ │ -[12555](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022ec0 __rt_psrelocs_end │ │ │ │ │ -[12556](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcf0 anon.07b55acb663eb35d742bae824872f75e.28.llvm.58757282566773765 │ │ │ │ │ -[12557](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008b8 __imp_ReadConsoleW │ │ │ │ │ -[12558](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000758 __imp_anon.71b4c3b3c7c90ed67c6b8e618b4d496a.1.llvm.14138378158770856212 │ │ │ │ │ -[12559](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006c8 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.22.llvm.13665133684747362110 │ │ │ │ │ -[12560](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001511f anon.7a6259c55b9abecd4a2eb0873fc8b779.38.llvm.10283439849247210698 │ │ │ │ │ -[12561](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c3130 __iob_func │ │ │ │ │ -[12562](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ad0 __imp_accept │ │ │ │ │ -[12563](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000020ce anon.577344e6c4a90a10ff600a929dedcba7.35.llvm.11685822864145163790 │ │ │ │ │ -[12564](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002570 anon.577344e6c4a90a10ff600a929dedcba7.82.llvm.11685822864145163790 │ │ │ │ │ -[12565](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a520 CreateThread │ │ │ │ │ -[12566](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000066f0 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.37.llvm.4036729494550109879 │ │ │ │ │ -[12567](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c3140 fwrite │ │ │ │ │ -[12568](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000378 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.4.llvm.65172163764165323 │ │ │ │ │ -[12569](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dba8 anon.07b55acb663eb35d742bae824872f75e.6.llvm.58757282566773765 │ │ │ │ │ -[12570](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cef anon.c5e06b7d2fb27e4271afbca860883ce8.29.llvm.12196597439006139751 │ │ │ │ │ -[12571](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015330 anon.7a6259c55b9abecd4a2eb0873fc8b779.69.llvm.10283439849247210698 │ │ │ │ │ -[12572](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013100 anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.0.llvm.12700038450165258506 │ │ │ │ │ -[12573](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000448 __imp_anon.941f0f04b36aa440174d89d326747b6f.14.llvm.16620058351426711825 │ │ │ │ │ -[12574](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a08 __imp_free │ │ │ │ │ -[12575](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000134c8 anon.3bd369ec61590d9272c591ac87029920.0.llvm.2123515186662715695 │ │ │ │ │ -[12576](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003918 anon.941f0f04b36aa440174d89d326747b6f.28.llvm.16620058351426711825 │ │ │ │ │ -[12577](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002a20 anon.edf9b0bdfd963b6a2ea99216811efd5e.4.llvm.65172163764165323 │ │ │ │ │ -[12578](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010d98 anon.567cec0599d353b04e33d4229b5f9b30.3.llvm.2628756017061842597 │ │ │ │ │ -[12579](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002b0 __imp__ZN3std10sys_common11thread_info11THREAD_INFO7__getit5__KEY17ha20a47e83639d552E.llvm.11685822864145163790 │ │ │ │ │ -[12580](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006240 anon.2fc0b598515d6d45a6f7a748d37f9e68.94.llvm.9180192027238945235 │ │ │ │ │ -[12581](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000028 __imp_anon.7ce35b53eeafc768de935b4fef3da959.11.llvm.1024159395525823541 │ │ │ │ │ -[12582](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000638 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.4.llvm.13665133684747362110 │ │ │ │ │ -[12583](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a330 RtlVirtualUnwind │ │ │ │ │ -[12584](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4c8 FlushFileBuffers │ │ │ │ │ -[12585](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004458 anon.ce6f0c62864fa439afba1682d1475d3d.80.llvm.14048921605721191922 │ │ │ │ │ -[12586](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000017300 anon.df4f5fc91c1c1e84f2976758feaea474.16.llvm.17095335174290335670 │ │ │ │ │ -[12587](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e70 anon.ce6f0c62864fa439afba1682d1475d3d.21.llvm.14048921605721191922 │ │ │ │ │ -[12588](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004d0 __imp__ZN3std3sys3pal7windows1c8KERNEL3217h9414b6c65f82effbE │ │ │ │ │ -[12589](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005738 anon.2fc0b598515d6d45a6f7a748d37f9e68.4.llvm.9180192027238945235 │ │ │ │ │ -[12590](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000103a0 anon.d13ef5d19e380ff1a25cb10df774bd92.4.llvm.13995198208019911955 │ │ │ │ │ -[12591](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a68 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.107.llvm.10386673973210777259 │ │ │ │ │ -[12592](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013c10 anon.1cd6cbb5d23cd003f709872fa6a8a6dd.30.llvm.9517595369394268439 │ │ │ │ │ -[12593](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003e0 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.85.llvm.65172163764165323 │ │ │ │ │ -[12594](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000408 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.116.llvm.65172163764165323 │ │ │ │ │ -[12595](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007c37 anon.5de116bb10f22f2f898f0999be20ad04.10.llvm.16857200617075268833 │ │ │ │ │ -[12596](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000780 __imp_GetCurrentThread │ │ │ │ │ -[12597](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a660 WSASend │ │ │ │ │ -[12598](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000b0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.22.llvm.12196597439006139751 │ │ │ │ │ -[12599](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009a0 __imp_WaitForMultipleObjects │ │ │ │ │ -[12600](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a38 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.101.llvm.10386673973210777259 │ │ │ │ │ -[12601](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000818 __imp_GetSystemDirectoryW │ │ │ │ │ -[12602](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000021e0 anon.577344e6c4a90a10ff600a929dedcba7.48.llvm.11685822864145163790 │ │ │ │ │ -[12603](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005590 anon.71b4c3b3c7c90ed67c6b8e618b4d496a.2.llvm.14138378158770856212 │ │ │ │ │ -[12604](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000047ee anon.a43af9cc4981a42dd00b013f8f55f130.5.llvm.13665133684747362110 │ │ │ │ │ -[12605](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000228 __imp_anon.577344e6c4a90a10ff600a929dedcba7.5.llvm.11685822864145163790 │ │ │ │ │ -[12606](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000062a4 anon.2fc0b598515d6d45a6f7a748d37f9e68.99.llvm.9180192027238945235 │ │ │ │ │ -[12607](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a320 SetEnvironmentVariableW │ │ │ │ │ -[12608](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006120 anon.2fc0b598515d6d45a6f7a748d37f9e68.86.llvm.9180192027238945235 │ │ │ │ │ -[12609](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000062b5 anon.2fc0b598515d6d45a6f7a748d37f9e68.101.llvm.9180192027238945235 │ │ │ │ │ -[12610](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015113 anon.7a6259c55b9abecd4a2eb0873fc8b779.35.llvm.10283439849247210698 │ │ │ │ │ -[12611](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000390 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.54.llvm.65172163764165323 │ │ │ │ │ -[12612](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003970 anon.941f0f04b36aa440174d89d326747b6f.31.llvm.16620058351426711825 │ │ │ │ │ -[12613](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005881 anon.2fc0b598515d6d45a6f7a748d37f9e68.17.llvm.9180192027238945235 │ │ │ │ │ -[12614](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006180 anon.2fc0b598515d6d45a6f7a748d37f9e68.88.llvm.9180192027238945235 │ │ │ │ │ -[12615](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a600 ioctlsocket │ │ │ │ │ -[12616](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006f68 anon.5188eecf01c48ed8fcadadd01fcebeeb.50.llvm.10386673973210777259 │ │ │ │ │ -[12617](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000840 anon.08c341bb7f186daefc16bdd18254cc9c.4.llvm.2852608270795916942 │ │ │ │ │ -[12618](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ca0 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.40.llvm.10283439849247210698 │ │ │ │ │ -[12619](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003c90 anon.ce6f0c62864fa439afba1682d1475d3d.0.llvm.14048921605721191922 │ │ │ │ │ -[12620](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000055f8 anon.71b4c3b3c7c90ed67c6b8e618b4d496a.6.llvm.14138378158770856212 │ │ │ │ │ -[12621](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000420 __imp_anon.941f0f04b36aa440174d89d326747b6f.6.llvm.16620058351426711825 │ │ │ │ │ -[12622](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ef0 _CRT_MT │ │ │ │ │ -[12623](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000648 __imp_WakeByAddressAll │ │ │ │ │ -[12624](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000980 __imp_UnmapViewOfFile │ │ │ │ │ -[12625](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000878 __imp_LeaveCriticalSection │ │ │ │ │ -[12626](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e28 __imp_anon.07b55acb663eb35d742bae824872f75e.26.llvm.58757282566773765 │ │ │ │ │ -[12627](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cc8 anon.c5e06b7d2fb27e4271afbca860883ce8.26.llvm.12196597439006139751 │ │ │ │ │ -[12628](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cb8 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.43.llvm.10283439849247210698 │ │ │ │ │ -[12629](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2b8 TlsAlloc │ │ │ │ │ -[12630](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3d8 GetTempPathW │ │ │ │ │ -[12631](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006279 anon.2fc0b598515d6d45a6f7a748d37f9e68.96.llvm.9180192027238945235 │ │ │ │ │ -[12632](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000171c0 anon.df4f5fc91c1c1e84f2976758feaea474.14.llvm.17095335174290335670 │ │ │ │ │ -[12633](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000dc0 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.21.llvm.17095335174290335670 │ │ │ │ │ -[12634](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000002 __minor_subsystem_version__ │ │ │ │ │ -[12635](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010e68 anon.567cec0599d353b04e33d4229b5f9b30.9.llvm.2628756017061842597 │ │ │ │ │ -[12636](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004e8 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.18.llvm.14048921605721191922 │ │ │ │ │ -[12637](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001268 anon.03a7b1eb39947173efb71e48c5b540f4.10.llvm.10021583357862909 │ │ │ │ │ -[12638](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000760 __imp_anon.71b4c3b3c7c90ed67c6b8e618b4d496a.2.llvm.14138378158770856212 │ │ │ │ │ -[12639](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000100000 __size_of_heap_reserve__ │ │ │ │ │ -[12640](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004877 anon.a43af9cc4981a42dd00b013f8f55f130.16.llvm.13665133684747362110 │ │ │ │ │ -[12641](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001396f anon.9de54bf691a285dd20d4e87e6b508fbd.9.llvm.12123695082059135366 │ │ │ │ │ -[12642](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4c0 FormatMessageW │ │ │ │ │ -[12643](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000016708 _ZN4core7unicode12unicode_data15grapheme_extend7OFFSETS17h442f9377d3be9cdfE.llvm.819651363561423643 │ │ │ │ │ -[12644](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2144 ProcessPrng │ │ │ │ │ -[12645](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000320 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.14.llvm.9587153679006429619 │ │ │ │ │ -[12646](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006b8 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.20.llvm.13665133684747362110 │ │ │ │ │ -[12647](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000b0 _ZN3std2io5stdio6stderr8INSTANCE17h050c730875ffdbc8E │ │ │ │ │ -[12648](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003930 anon.941f0f04b36aa440174d89d326747b6f.29.llvm.16620058351426711825 │ │ │ │ │ -[12649](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a338 RtlLookupFunctionEntry │ │ │ │ │ -[12650](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c40 .refptr.__xi_a │ │ │ │ │ -[12651](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a28 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.70.llvm.10386673973210777259 │ │ │ │ │ -[12652](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009c8 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.12.llvm.10386673973210777259 │ │ │ │ │ -[12653](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a50 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.104.llvm.10386673973210777259 │ │ │ │ │ -[12654](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000064 _head_lib64_libuserenv_a │ │ │ │ │ -[12655](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4d0 FindNextFileW │ │ │ │ │ -[12656](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003900 anon.941f0f04b36aa440174d89d326747b6f.27.llvm.16620058351426711825 │ │ │ │ │ -[12657](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c20 __imp_anon.9de54bf691a285dd20d4e87e6b508fbd.7.llvm.12123695082059135366 │ │ │ │ │ -[12658](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009f0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.46.llvm.10386673973210777259 │ │ │ │ │ -[12659](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cf8 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.64.llvm.10283439849247210698 │ │ │ │ │ -[12660](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d60 __imp_anon.8d718ed12c404e6593cdb19a2e5276ea.22.llvm.819651363561423643 │ │ │ │ │ -[12661](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000870 anon.08c341bb7f186daefc16bdd18254cc9c.6.llvm.2852608270795916942 │ │ │ │ │ -[12662](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000079d8 anon.b600da5f5c44c0dd2674915485b1c9f6.0.llvm.9103046057031032332 │ │ │ │ │ -[12663](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c50 .refptr.__xi_z │ │ │ │ │ -[12664](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a438 GetLastError │ │ │ │ │ -[12665](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000138 _ZN3std3sys3pal7windows5alloc4HEAP17h34e549f5a2364763E │ │ │ │ │ -[12666](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000428 __imp_anon.941f0f04b36aa440174d89d326747b6f.10.llvm.16620058351426711825 │ │ │ │ │ -[12667](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000b8 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.23.llvm.12196597439006139751 │ │ │ │ │ -[12668](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b60 __imp_anon.7ec0d7d1b51f482853d19890eaa43e99.0.llvm.4855701895496871646 │ │ │ │ │ -[12669](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000878 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.96.llvm.9180192027238945235 │ │ │ │ │ -[12670](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007f8 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.43.llvm.9180192027238945235 │ │ │ │ │ -[12671](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e60 __imp__ZN4core3num7dec2flt5table17POWER_OF_FIVE_12817h1308de4d59502321E │ │ │ │ │ -[12672](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b58 __imp_anon.d5e7fe67f7f67b071ebb27a2ce9d6115.0.llvm.16008337483328089059 │ │ │ │ │ -[12673](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006fa0 anon.5188eecf01c48ed8fcadadd01fcebeeb.52.llvm.10386673973210777259 │ │ │ │ │ -[12674](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000220 __imp_anon.577344e6c4a90a10ff600a929dedcba7.4.llvm.11685822864145163790 │ │ │ │ │ -[12675](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b78 __imp__Unwind_GetDataRelBase │ │ │ │ │ -[12676](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000308 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.7.llvm.9587153679006429619 │ │ │ │ │ -[12677](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000020f0 anon.577344e6c4a90a10ff600a929dedcba7.36.llvm.11685822864145163790 │ │ │ │ │ -[12678](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000028 _head_lib64_libkernel32_a │ │ │ │ │ -[12679](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006a38 anon.5188eecf01c48ed8fcadadd01fcebeeb.3.llvm.10386673973210777259 │ │ │ │ │ -[12680](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000728 __imp_FindClose │ │ │ │ │ -[12681](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000798 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.14.llvm.9180192027238945235 │ │ │ │ │ -[12682](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a560 CreateDirectoryW │ │ │ │ │ -[12683](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001288 anon.03a7b1eb39947173efb71e48c5b540f4.11.llvm.10021583357862909 │ │ │ │ │ -[12684](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000044d0 anon.ce6f0c62864fa439afba1682d1475d3d.84.llvm.14048921605721191922 │ │ │ │ │ -[12685](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000018 pcinit │ │ │ │ │ -[12686](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000860 __imp_InitOnceComplete │ │ │ │ │ -[12687](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000918 __imp_SetFileTime │ │ │ │ │ -[12688](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004430 anon.ce6f0c62864fa439afba1682d1475d3d.79.llvm.14048921605721191922 │ │ │ │ │ -[12689](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c3170 InitializeCriticalSection │ │ │ │ │ -[12690](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004b8 __imp_anon.941f0f04b36aa440174d89d326747b6f.58.llvm.16620058351426711825 │ │ │ │ │ -[12691](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ab0 anon.c5e06b7d2fb27e4271afbca860883ce8.7.llvm.12196597439006139751 │ │ │ │ │ -[12692](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000012f90 anon.7ec0d7d1b51f482853d19890eaa43e99.13.llvm.4855701895496871646 │ │ │ │ │ -[12693](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a70 __imp___rust_alloc_error_handler_should_panic │ │ │ │ │ -[12694](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000560 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.83.llvm.14048921605721191922 │ │ │ │ │ -[12695](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000de0 __imp_anon.07b55acb663eb35d742bae824872f75e.12.llvm.58757282566773765 │ │ │ │ │ -[12696](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000af0 __imp_anon.d13ef5d19e380ff1a25cb10df774bd92.4.llvm.13995198208019911955 │ │ │ │ │ -[12697](sec 11)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 _tls_start │ │ │ │ │ -[12698](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bb8 __imp__Unwind_SetIP │ │ │ │ │ -[12699](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000888 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.99.llvm.9180192027238945235 │ │ │ │ │ -[12700](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000002159e anon.d5fd6146a7cb5ea87f639cab18b2a05b.46.llvm.3779847476987057767 │ │ │ │ │ -[12701](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a558 CreateEventW │ │ │ │ │ -[12702](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000888 __imp_Module32FirstW │ │ │ │ │ -[12703](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a388 Module32NextW │ │ │ │ │ -[12704](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b50 __imp_anon.c4d194f4cabed4ef9246cda43331cffc.5.llvm.6008810897942320446 │ │ │ │ │ -[12705](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015132 anon.7a6259c55b9abecd4a2eb0873fc8b779.48.llvm.10283439849247210698 │ │ │ │ │ -[12706](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000001a0 __mingw_app_type │ │ │ │ │ -[12707](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e68 __imp__ZN4core7unicode12unicode_data11white_space14WHITESPACE_MAP17h6da2769d9619e572E │ │ │ │ │ -[12708](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004be8 anon.a43af9cc4981a42dd00b013f8f55f130.59.llvm.13665133684747362110 │ │ │ │ │ -[12709](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000778 __imp_GetCurrentProcessId │ │ │ │ │ -[12710](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5d8 send │ │ │ │ │ -[12711](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000200000 __size_of_stack_reserve__ │ │ │ │ │ -[12712](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c80 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.36.llvm.10283439849247210698 │ │ │ │ │ -[12713](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000568 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.84.llvm.14048921605721191922 │ │ │ │ │ -[12714](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002a48 anon.edf9b0bdfd963b6a2ea99216811efd5e.5.llvm.65172163764165323 │ │ │ │ │ -[12715](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009c0 __imp_WriteFileEx │ │ │ │ │ -[12716](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000df8 __imp_anon.07b55acb663eb35d742bae824872f75e.20.llvm.58757282566773765 │ │ │ │ │ -[12717](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000810 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.46.llvm.9180192027238945235 │ │ │ │ │ -[12718](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000648 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.6.llvm.13665133684747362110 │ │ │ │ │ -[12719](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e90 __imp_anon.d5fd6146a7cb5ea87f639cab18b2a05b.44.llvm.3779847476987057767 │ │ │ │ │ -[12720](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a298 UnmapViewOfFile │ │ │ │ │ -[12721](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002de0 anon.edf9b0bdfd963b6a2ea99216811efd5e.53.llvm.65172163764165323 │ │ │ │ │ -[12722](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcd0 anon.07b55acb663eb35d742bae824872f75e.26.llvm.58757282566773765 │ │ │ │ │ -[12723](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ee0 __native_vcclrit_reason │ │ │ │ │ -[12724](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a518 CreateToolhelp32Snapshot │ │ │ │ │ -[12725](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c88 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.37.llvm.10283439849247210698 │ │ │ │ │ -[12726](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a68 __imp_NtReadFile │ │ │ │ │ -[12727](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009e0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.15.llvm.10386673973210777259 │ │ │ │ │ -[12728](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a628 freeaddrinfo │ │ │ │ │ -[12729](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000081a8 anon.fc3e879c0d0583c039a7967db6c0c117.0.llvm.14670435032436802275 │ │ │ │ │ -[12730](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000028a8 anon.2d4ed69d03b8b00b295e2865b118c80a.16.llvm.9587153679006429619 │ │ │ │ │ -[12731](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000017050 anon.df4f5fc91c1c1e84f2976758feaea474.2.llvm.17095335174290335670 │ │ │ │ │ -[12732](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000700 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.59.llvm.13665133684747362110 │ │ │ │ │ -[12733](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000128 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.3.llvm.10021583357862909 │ │ │ │ │ -[12734](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000850 __imp_HeapReAlloc │ │ │ │ │ -[12735](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a08 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.49.llvm.10386673973210777259 │ │ │ │ │ -[12736](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000c8 anon.7ce35b53eeafc768de935b4fef3da959.4.llvm.1024159395525823541 │ │ │ │ │ -[12737](sec 0)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __end__ │ │ │ │ │ -[12738](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003c38 anon.941f0f04b36aa440174d89d326747b6f.60.llvm.16620058351426711825 │ │ │ │ │ -[12739](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e40 __imp_anon.07b55acb663eb35d742bae824872f75e.29.llvm.58757282566773765 │ │ │ │ │ -[12740](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005bb8 anon.2fc0b598515d6d45a6f7a748d37f9e68.46.llvm.9180192027238945235 │ │ │ │ │ -[12741](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000108 __imp_anon.2611162d579b3e706d0c0f15accb8ea6.2.llvm.17987727548992354187 │ │ │ │ │ -[12742](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cc0 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.44.llvm.10283439849247210698 │ │ │ │ │ -[12743](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000221a anon.577344e6c4a90a10ff600a929dedcba7.51.llvm.11685822864145163790 │ │ │ │ │ -[12744](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002158 anon.577344e6c4a90a10ff600a929dedcba7.41.llvm.11685822864145163790 │ │ │ │ │ -[12745](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007e88 anon.75cd115d168aa5adc70873d7be22c67a.7.llvm.8768119154728042530 │ │ │ │ │ -[12746](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bf0 __imp_anon.bb01d4b423a85a795a1692e8cd9c64e5.9.llvm.11285312269184381906 │ │ │ │ │ -[12747](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ba0 __imp__Unwind_RaiseException │ │ │ │ │ -[12748](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007b8 __imp_GetFileType │ │ │ │ │ -[12749](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009b8 __imp_WriteConsoleW │ │ │ │ │ -[12750](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007d8 __imp_GetModuleFileNameW │ │ │ │ │ -[12751](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006e8 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.54.llvm.13665133684747362110 │ │ │ │ │ -[12752](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000430 __imp_anon.941f0f04b36aa440174d89d326747b6f.11.llvm.16620058351426711825 │ │ │ │ │ -[12753](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b80 __imp_anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.0.llvm.12700038450165258506 │ │ │ │ │ -[12754](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 _head__tmp_rustcBv6EAf_api_ms_win_core_synch_l1_2_0_lib │ │ │ │ │ +[12262](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 _head__tmp_rustcpdeyFw_api_ms_win_core_synch_l1_2_0_lib │ │ │ │ │ +[12263](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000046f2 anon.ce6f0c62864fa439afba1682d1475d3d.118.llvm.14048921605721191922 │ │ │ │ │ +[12264](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000218 __imp_anon.577344e6c4a90a10ff600a929dedcba7.3.llvm.11685822864145163790 │ │ │ │ │ +[12265](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006d0 __imp_CreateSymbolicLinkW │ │ │ │ │ +[12266](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a570 CompareStringOrdinal │ │ │ │ │ +[12267](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000069e0 anon.5188eecf01c48ed8fcadadd01fcebeeb.1.llvm.10386673973210777259 │ │ │ │ │ +[12268](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2370 memmove │ │ │ │ │ +[12269](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000026d0 anon.2d4ed69d03b8b00b295e2865b118c80a.1.llvm.9587153679006429619 │ │ │ │ │ +[12270](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a528 CreateSymbolicLinkW │ │ │ │ │ +[12271](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e50 anon.ce6f0c62864fa439afba1682d1475d3d.20.llvm.14048921605721191922 │ │ │ │ │ +[12272](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004a50 anon.a43af9cc4981a42dd00b013f8f55f130.49.llvm.13665133684747362110 │ │ │ │ │ +[12273](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013198 anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.7.llvm.12700038450165258506 │ │ │ │ │ +[12274](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000e0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.27.llvm.12196597439006139751 │ │ │ │ │ +[12275](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000398 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.55.llvm.65172163764165323 │ │ │ │ │ +[12276](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000c0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.24.llvm.12196597439006139751 │ │ │ │ │ +[12277](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004260 anon.ce6f0c62864fa439afba1682d1475d3d.63.llvm.14048921605721191922 │ │ │ │ │ +[12278](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007a8 __imp_GetFileInformationByHandle │ │ │ │ │ +[12279](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000148 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.9.llvm.10021583357862909 │ │ │ │ │ +[12280](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __rt_psrelocs_size │ │ │ │ │ +[12281](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b88 __imp_anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.3.llvm.12700038450165258506 │ │ │ │ │ +[12282](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000021270 anon.d5fd6146a7cb5ea87f639cab18b2a05b.42.llvm.3779847476987057767 │ │ │ │ │ +[12283](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2c0 TerminateProcess │ │ │ │ │ +[12284](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002e26 anon.edf9b0bdfd963b6a2ea99216811efd5e.54.llvm.65172163764165323 │ │ │ │ │ +[12285](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e80 __imp_anon.d5fd6146a7cb5ea87f639cab18b2a05b.42.llvm.3779847476987057767 │ │ │ │ │ +[12286](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c3148 strncmp │ │ │ │ │ +[12287](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a668 WSARecv │ │ │ │ │ +[12288](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b70 __imp_anon.7ec0d7d1b51f482853d19890eaa43e99.14.llvm.4855701895496871646 │ │ │ │ │ +[12289](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000750 __imp_FreeEnvironmentStringsW │ │ │ │ │ +[12290](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2160 WaitOnAddress │ │ │ │ │ +[12291](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000898 __imp_MoveFileExW │ │ │ │ │ +[12292](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000078 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.1.llvm.12196597439006139751 │ │ │ │ │ +[12293](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022bd0 .refptr.__mingw_app_type │ │ │ │ │ +[12294](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5f0 recv │ │ │ │ │ +[12295](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000538 __imp__ZN3std10sys_common6thread9min_stack3MIN17hd6c24a62017ef65aE.0.llvm.14048921605721191922 │ │ │ │ │ +[12296](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006228 anon.2fc0b598515d6d45a6f7a748d37f9e68.93.llvm.9180192027238945235 │ │ │ │ │ +[12297](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ac8 __imp_anon.75cd115d168aa5adc70873d7be22c67a.12.llvm.8768119154728042530 │ │ │ │ │ +[12298](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000eb0 __imp__execute_onexit_table │ │ │ │ │ +[12299](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007eb3 anon.75cd115d168aa5adc70873d7be22c67a.9.llvm.8768119154728042530 │ │ │ │ │ +[12300](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000898 _ZN3std3sys3pal7windows1c13GetTempPath2W3PTR17he23b5a39201cf65cE │ │ │ │ │ +[12301](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000046ea anon.ce6f0c62864fa439afba1682d1475d3d.117.llvm.14048921605721191922 │ │ │ │ │ +[12302](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000970 __imp_TlsGetValue │ │ │ │ │ +[12303](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a508 DeleteFileW │ │ │ │ │ +[12304](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c98 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.39.llvm.10283439849247210698 │ │ │ │ │ +[12305](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000640 __imp_WaitOnAddress │ │ │ │ │ +[12306](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001e98 anon.577344e6c4a90a10ff600a929dedcba7.5.llvm.11685822864145163790 │ │ │ │ │ +[12307](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000758 __imp_GetCommandLineW │ │ │ │ │ +[12308](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c21b8 _Unwind_DeleteException │ │ │ │ │ +[12309](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a488 GetCurrentThread │ │ │ │ │ +[12310](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004895 anon.a43af9cc4981a42dd00b013f8f55f130.18.llvm.13665133684747362110 │ │ │ │ │ +[12311](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d89 anon.2611162d579b3e706d0c0f15accb8ea6.3.llvm.17987727548992354187 │ │ │ │ │ +[12312](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a88 __imp_anon.e2378e14a3ab6920970de912c40858fb.1.llvm.12155384279649763508 │ │ │ │ │ +[12313](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015131 anon.7a6259c55b9abecd4a2eb0873fc8b779.47.llvm.10283439849247210698 │ │ │ │ │ +[12314](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000858 __imp_InitOnceBeginInitialize │ │ │ │ │ +[12315](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000eb8 __imp__register_onexit_function │ │ │ │ │ +[12316](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006a20 anon.5188eecf01c48ed8fcadadd01fcebeeb.2.llvm.10386673973210777259 │ │ │ │ │ +[12317](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008c0 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.3.llvm.4036729494550109879 │ │ │ │ │ +[12318](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006168 anon.2fc0b598515d6d45a6f7a748d37f9e68.87.llvm.9180192027238945235 │ │ │ │ │ +[12319](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2a8 TlsGetValue │ │ │ │ │ +[12320](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000150 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.10.llvm.10021583357862909 │ │ │ │ │ +[12321](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a80 __imp_anon.b600da5f5c44c0dd2674915485b1c9f6.0.llvm.9103046057031032332 │ │ │ │ │ +[12322](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000173a0 anon.df4f5fc91c1c1e84f2976758feaea474.21.llvm.17095335174290335670 │ │ │ │ │ +[12323](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c2330 _amsg_exit │ │ │ │ │ +[12324](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013d20 _ZN4core3num7flt2dec8strategy5grisu12CACHED_POW1017hc29b3bf8237d228dE │ │ │ │ │ +[12325](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000160 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.13.llvm.10021583357862909 │ │ │ │ │ +[12326](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2d0 SleepEx │ │ │ │ │ +[12327](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001510c anon.7a6259c55b9abecd4a2eb0873fc8b779.32.llvm.10283439849247210698 │ │ │ │ │ +[12328](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002540 anon.577344e6c4a90a10ff600a929dedcba7.81.llvm.11685822864145163790 │ │ │ │ │ +[12329](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005b70 anon.2fc0b598515d6d45a6f7a748d37f9e68.44.llvm.9180192027238945235 │ │ │ │ │ +[12330](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000020 _ZN3std5panic14SHOULD_CAPTURE17h47fa1dca84a94988E.0.llvm.12196597439006139751 │ │ │ │ │ +[12331](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015130 anon.7a6259c55b9abecd4a2eb0873fc8b779.46.llvm.10283439849247210698 │ │ │ │ │ +[12332](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000138c8 anon.9de54bf691a285dd20d4e87e6b508fbd.4.llvm.12123695082059135366 │ │ │ │ │ +[12333](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000790 __imp_GetEnvironmentVariableW │ │ │ │ │ +[12334](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d38 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.72.llvm.10283439849247210698 │ │ │ │ │ +[12335](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002880 anon.2d4ed69d03b8b00b295e2865b118c80a.15.llvm.9587153679006429619 │ │ │ │ │ +[12336](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ee4 __native_dllmain_reason │ │ │ │ │ +[12337](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003b85 anon.941f0f04b36aa440174d89d326747b6f.54.llvm.16620058351426711825 │ │ │ │ │ +[12338](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005578 anon.71b4c3b3c7c90ed67c6b8e618b4d496a.1.llvm.14138378158770856212 │ │ │ │ │ +[12339](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000890 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.101.llvm.9180192027238945235 │ │ │ │ │ +[12340](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013938 anon.9de54bf691a285dd20d4e87e6b508fbd.7.llvm.12123695082059135366 │ │ │ │ │ +[12341](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005b88 anon.2fc0b598515d6d45a6f7a748d37f9e68.45.llvm.9180192027238945235 │ │ │ │ │ +[12342](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009f8 anon.c5e06b7d2fb27e4271afbca860883ce8.2.llvm.12196597439006139751 │ │ │ │ │ +[12343](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000770 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.4.llvm.9180192027238945235 │ │ │ │ │ +[12344](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000050 __imp_anon.08c341bb7f186daefc16bdd18254cc9c.4.llvm.2852608270795916942 │ │ │ │ │ +[12345](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000950 __imp_SwitchToThread │ │ │ │ │ +[12346](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d20 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.69.llvm.10283439849247210698 │ │ │ │ │ +[12347](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000940 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.41.llvm.4036729494550109879 │ │ │ │ │ +[12348](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006a8 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.18.llvm.13665133684747362110 │ │ │ │ │ +[12349](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000660 __imp_ProcessPrng │ │ │ │ │ +[12350](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a278 WideCharToMultiByte │ │ │ │ │ +[12351](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001a10 __lib64_libmsvcrt_def_a_iname │ │ │ │ │ +[12352](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015ef0 anon.8d718ed12c404e6593cdb19a2e5276ea.6.llvm.819651363561423643 │ │ │ │ │ +[12353](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008e0 __imp_RtlLookupFunctionEntry │ │ │ │ │ +[12354](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000dd8 __imp_anon.07b55acb663eb35d742bae824872f75e.9.llvm.58757282566773765 │ │ │ │ │ +[12355](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006f8 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.58.llvm.13665133684747362110 │ │ │ │ │ +[12356](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000810 __imp_GetStdHandle │ │ │ │ │ +[12357](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004e0 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.17.llvm.14048921605721191922 │ │ │ │ │ +[12358](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e88 anon.ce6f0c62864fa439afba1682d1475d3d.22.llvm.14048921605721191922 │ │ │ │ │ +[12359](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006f88 anon.5188eecf01c48ed8fcadadd01fcebeeb.51.llvm.10386673973210777259 │ │ │ │ │ +[12360](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a430 GetModuleFileNameW │ │ │ │ │ +[12361](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000017d0 ___tmp_rustcpdeyFw_api_ms_win_core_synch_l1_2_0_lib_iname │ │ │ │ │ +[12362](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a420 GetModuleHandleW │ │ │ │ │ +[12363](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a428 GetModuleHandleA │ │ │ │ │ +[12364](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000188 _ZN3std9panicking11panic_count17LOCAL_PANIC_COUNT7__getit5__KEY17h6b4730867b4d8da1E.llvm.11685822864145163790 │ │ │ │ │ +[12365](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000135d0 _ZN4core3fmt3num14DEC_DIGITS_LUT17h038d33b26edcbfd2E │ │ │ │ │ +[12366](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000900 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.31.llvm.4036729494550109879 │ │ │ │ │ +[12367](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a500 DeleteProcThreadAttributeList │ │ │ │ │ +[12368](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008d0 __imp_RemoveDirectoryW │ │ │ │ │ +[12369](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bf8 __imp_anon.bb01d4b423a85a795a1692e8cd9c64e5.10.llvm.11285312269184381906 │ │ │ │ │ +[12370](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e48 __imp_anon.07b55acb663eb35d742bae824872f75e.30.llvm.58757282566773765 │ │ │ │ │ +[12371](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a30 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.71.llvm.10386673973210777259 │ │ │ │ │ +[12372](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b98 __imp_anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.6.llvm.12700038450165258506 │ │ │ │ │ +[12373](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a60 __imp_NtCreateFile │ │ │ │ │ +[12374](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ea8 __imp_anon.d5fd6146a7cb5ea87f639cab18b2a05b.47.llvm.3779847476987057767 │ │ │ │ │ +[12375](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c20 .refptr.__xc_a │ │ │ │ │ +[12376](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000690 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.15.llvm.13665133684747362110 │ │ │ │ │ +[12377](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022b70 .refptr._ZN3std9panicking11panic_count18GLOBAL_PANIC_COUNT17h5b40b3f81b5486b3E │ │ │ │ │ +[12378](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c38 __imp_anon.1cd6cbb5d23cd003f709872fa6a8a6dd.8.llvm.9517595369394268439 │ │ │ │ │ +[12379](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000026f8 anon.2d4ed69d03b8b00b295e2865b118c80a.2.llvm.9587153679006429619 │ │ │ │ │ +[12380](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000098 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.8.llvm.12196597439006139751 │ │ │ │ │ +[12381](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e10 anon.ce6f0c62864fa439afba1682d1475d3d.17.llvm.14048921605721191922 │ │ │ │ │ +[12382](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003000 anon.edf9b0bdfd963b6a2ea99216811efd5e.77.llvm.65172163764165323 │ │ │ │ │ +[12383](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a370 QueryPerformanceCounter │ │ │ │ │ +[12384](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a580 CancelIo │ │ │ │ │ +[12385](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2158 WakeByAddressAll │ │ │ │ │ +[12386](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008a8 __imp_QueryPerformanceCounter │ │ │ │ │ +[12387](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000850 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.90.llvm.9180192027238945235 │ │ │ │ │ +[12388](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003820 anon.941f0f04b36aa440174d89d326747b6f.20.llvm.16620058351426711825 │ │ │ │ │ +[12389](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e20 __imp_anon.07b55acb663eb35d742bae824872f75e.25.llvm.58757282566773765 │ │ │ │ │ +[12390](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a598 NtWriteFile │ │ │ │ │ +[12391](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000528 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.63.llvm.14048921605721191922 │ │ │ │ │ +[12392](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000978 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.59.llvm.4036729494550109879 │ │ │ │ │ +[12393](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcd8 anon.07b55acb663eb35d742bae824872f75e.27.llvm.58757282566773765 │ │ │ │ │ +[12394](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009e8 __imp__lock │ │ │ │ │ +[12395](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000aa0 __imp_anon.75cd115d168aa5adc70873d7be22c67a.6.llvm.8768119154728042530 │ │ │ │ │ +[12396](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013900 str.0.llvm.12123695082059135366 │ │ │ │ │ +[12397](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c70 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.34.llvm.10283439849247210698 │ │ │ │ │ +[12398](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001868 anon.03a7b1eb39947173efb71e48c5b540f4.82.llvm.10021583357862909 │ │ │ │ │ +[12399](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d50 __imp_anon.8d718ed12c404e6593cdb19a2e5276ea.6.llvm.819651363561423643 │ │ │ │ │ +[12400](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000730 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.115.llvm.13665133684747362110 │ │ │ │ │ +[12401](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d98 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.16.llvm.17095335174290335670 │ │ │ │ │ +[12402](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000150 _ZN3std3sys3pal7windows4time12perf_counter9frequency9FREQUENCY17hb6767d30e4f028d6E.0.llvm.10386673973210777259 │ │ │ │ │ +[12403](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003d8 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.84.llvm.65172163764165323 │ │ │ │ │ +[12404](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006670 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.32.llvm.4036729494550109879 │ │ │ │ │ +[12405](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a480 GetEnvironmentStringsW │ │ │ │ │ +[12406](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000012948 anon.c4d194f4cabed4ef9246cda43331cffc.3.llvm.6008810897942320446 │ │ │ │ │ +[12407](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000180 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.83.llvm.10021583357862909 │ │ │ │ │ +[12408](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004c50 anon.a43af9cc4981a42dd00b013f8f55f130.65.llvm.13665133684747362110 │ │ │ │ │ +[12409](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b10 __imp_getsockopt │ │ │ │ │ +[12410](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000002138c anon.d5fd6146a7cb5ea87f639cab18b2a05b.44.llvm.3779847476987057767 │ │ │ │ │ +[12411](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c00 __imp_anon.9de54bf691a285dd20d4e87e6b508fbd.4.llvm.12123695082059135366 │ │ │ │ │ +[12412](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a548 CreateFileW │ │ │ │ │ +[12413](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e98 __imp_anon.d5fd6146a7cb5ea87f639cab18b2a05b.45.llvm.3779847476987057767 │ │ │ │ │ +[12414](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c21c0 _GCC_specific_handler │ │ │ │ │ +[12415](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000788 __imp_GetEnvironmentStringsW │ │ │ │ │ +[12416](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000068b8 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.59.llvm.4036729494550109879 │ │ │ │ │ +[12417](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007edb anon.75cd115d168aa5adc70873d7be22c67a.10.llvm.8768119154728042530 │ │ │ │ │ +[12418](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c3178 EnterCriticalSection │ │ │ │ │ +[12419](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cee anon.c5e06b7d2fb27e4271afbca860883ce8.28.llvm.12196597439006139751 │ │ │ │ │ +[12420](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004d8 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.0.llvm.14048921605721191922 │ │ │ │ │ +[12421](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006c8 __imp_CreateProcessW │ │ │ │ │ +[12422](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000060d0 anon.2fc0b598515d6d45a6f7a748d37f9e68.83.llvm.9180192027238945235 │ │ │ │ │ +[12423](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013160 anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.5.llvm.12700038450165258506 │ │ │ │ │ +[12424](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c3150 vfprintf │ │ │ │ │ +[12425](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d00 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.65.llvm.10283439849247210698 │ │ │ │ │ +[12426](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a550 CreateFileMappingA │ │ │ │ │ +[12427](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000440 __imp_anon.941f0f04b36aa440174d89d326747b6f.13.llvm.16620058351426711825 │ │ │ │ │ +[12428](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b78 __imp_anon.7ec0d7d1b51f482853d19890eaa43e99.15.llvm.4855701895496871646 │ │ │ │ │ +[12429](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000061e0 anon.2fc0b598515d6d45a6f7a748d37f9e68.90.llvm.9180192027238945235 │ │ │ │ │ +[12430](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000229c0 _tls_used │ │ │ │ │ +[12431](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000450 __imp_anon.941f0f04b36aa440174d89d326747b6f.20.llvm.16620058351426711825 │ │ │ │ │ +[12432](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000012930 anon.c4d194f4cabed4ef9246cda43331cffc.1.llvm.6008810897942320446 │ │ │ │ │ +[12433](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000158 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.11.llvm.10021583357862909 │ │ │ │ │ +[12434](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000048a2 anon.a43af9cc4981a42dd00b013f8f55f130.19.llvm.13665133684747362110 │ │ │ │ │ +[12435](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007469 anon.5188eecf01c48ed8fcadadd01fcebeeb.103.llvm.10386673973210777259 │ │ │ │ │ +[12436](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006f8 __imp_DeleteFileW │ │ │ │ │ +[12437](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000048dc anon.a43af9cc4981a42dd00b013f8f55f130.23.llvm.13665133684747362110 │ │ │ │ │ +[12438](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000da0 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.17.llvm.17095335174290335670 │ │ │ │ │ +[12439](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000328 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.15.llvm.9587153679006429619 │ │ │ │ │ +[12440](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000032a8 anon.edf9b0bdfd963b6a2ea99216811efd5e.116.llvm.65172163764165323 │ │ │ │ │ +[12441](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b58 __imp_shutdown │ │ │ │ │ +[12442](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b18 __imp_anon.567cec0599d353b04e33d4229b5f9b30.12.llvm.2628756017061842597 │ │ │ │ │ +[12443](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000180 __native_startup_lock │ │ │ │ │ +[12444](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002820 anon.2d4ed69d03b8b00b295e2865b118c80a.12.llvm.9587153679006429619 │ │ │ │ │ +[12445](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022ec0 __RUNTIME_PSEUDO_RELOC_LIST_END__ │ │ │ │ │ +[12446](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000028d0 anon.2d4ed69d03b8b00b295e2865b118c80a.17.llvm.9587153679006429619 │ │ │ │ │ +[12447](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000008 __xc_z │ │ │ │ │ +[12448](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007b0 __imp_GetFileInformationByHandleEx │ │ │ │ │ +[12449](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000030 __imp_anon.7ce35b53eeafc768de935b4fef3da959.12.llvm.1024159395525823541 │ │ │ │ │ +[12450](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a398 MapViewOfFile │ │ │ │ │ +[12451](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000017358 anon.df4f5fc91c1c1e84f2976758feaea474.19.llvm.17095335174290335670 │ │ │ │ │ +[12452](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006300 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.2.llvm.4036729494550109879 │ │ │ │ │ +[12453](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b20 __imp_listen │ │ │ │ │ +[12454](sec 11)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000010 ___tls_end__ │ │ │ │ │ +[12455](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003a58 anon.941f0f04b36aa440174d89d326747b6f.42.llvm.16620058351426711825 │ │ │ │ │ +[12456](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ba8 __imp__Unwind_Resume │ │ │ │ │ +[12457](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007f0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.42.llvm.9180192027238945235 │ │ │ │ │ +[12458](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000828 __imp_GetSystemTimePreciseAsFileTime │ │ │ │ │ +[12459](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015111 anon.7a6259c55b9abecd4a2eb0873fc8b779.34.llvm.10283439849247210698 │ │ │ │ │ +[12460](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000001e8 _ZN3std2io5stdio14OUTPUT_CAPTURE7__getit5__KEY17h4bf77338c012dfcbE.llvm.11685822864145163790 │ │ │ │ │ +[12461](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000110 __imp_anon.2611162d579b3e706d0c0f15accb8ea6.3.llvm.17987727548992354187 │ │ │ │ │ +[12462](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000050 ___crt_xp_start__ │ │ │ │ │ +[12463](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b68 __imp__GCC_specific_handler │ │ │ │ │ +[12464](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000918 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.34.llvm.4036729494550109879 │ │ │ │ │ +[12465](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015129 anon.7a6259c55b9abecd4a2eb0873fc8b779.41.llvm.10283439849247210698 │ │ │ │ │ +[12466](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000058f8 anon.2fc0b598515d6d45a6f7a748d37f9e68.20.llvm.9180192027238945235 │ │ │ │ │ +[12467](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008b8 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.2.llvm.4036729494550109879 │ │ │ │ │ +[12468](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000678 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.12.llvm.13665133684747362110 │ │ │ │ │ +[12469](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a280 WaitForSingleObject │ │ │ │ │ +[12470](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001248 anon.03a7b1eb39947173efb71e48c5b540f4.9.llvm.10021583357862909 │ │ │ │ │ +[12471](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015128 anon.7a6259c55b9abecd4a2eb0873fc8b779.40.llvm.10283439849247210698 │ │ │ │ │ +[12472](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a350 ReadFileEx │ │ │ │ │ +[12473](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000718 __imp__ZN3std9panicking4HOOK17h33440ca34cb79643E │ │ │ │ │ +[12474](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000d0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.26.llvm.12196597439006139751 │ │ │ │ │ +[12475](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a98 __imp_WSACleanup │ │ │ │ │ +[12476](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007a8 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.16.llvm.9180192027238945235 │ │ │ │ │ +[12477](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000170 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.52.llvm.10021583357862909 │ │ │ │ │ +[12478](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a610 getsockname │ │ │ │ │ +[12479](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000208f8 _ZN4core7unicode12unicode_data11white_space14WHITESPACE_MAP17h6da2769d9619e572E │ │ │ │ │ +[12480](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c30 .refptr.__xc_z │ │ │ │ │ +[12481](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dd38 anon.07b55acb663eb35d742bae824872f75e.30.llvm.58757282566773765 │ │ │ │ │ +[12482](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d18 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.68.llvm.10283439849247210698 │ │ │ │ │ +[12483](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000061c8 anon.2fc0b598515d6d45a6f7a748d37f9e68.89.llvm.9180192027238945235 │ │ │ │ │ +[12484](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000750 __imp_anon.71b4c3b3c7c90ed67c6b8e618b4d496a.0.llvm.14138378158770856212 │ │ │ │ │ +[12485](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008b0 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.1.llvm.4036729494550109879 │ │ │ │ │ +[12486](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a318 SetFileAttributesW │ │ │ │ │ +[12487](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000458 __imp_anon.941f0f04b36aa440174d89d326747b6f.27.llvm.16620058351426711825 │ │ │ │ │ +[12488](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d58 __imp_anon.8d718ed12c404e6593cdb19a2e5276ea.18.llvm.819651363561423643 │ │ │ │ │ +[12489](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010dd0 anon.567cec0599d353b04e33d4229b5f9b30.4.llvm.2628756017061842597 │ │ │ │ │ +[12490](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006d0 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.23.llvm.13665133684747362110 │ │ │ │ │ +[12491](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000074b0 anon.5188eecf01c48ed8fcadadd01fcebeeb.106.llvm.10386673973210777259 │ │ │ │ │ +[12492](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009a8 __imp_WaitForSingleObject │ │ │ │ │ +[12493](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000460 __imp_anon.941f0f04b36aa440174d89d326747b6f.28.llvm.16620058351426711825 │ │ │ │ │ +[12494](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a90 __imp_anon.5de116bb10f22f2f898f0999be20ad04.10.llvm.16857200617075268833 │ │ │ │ │ +[12495](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000048 __xl_z │ │ │ │ │ +[12496](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000002154e anon.d5fd6146a7cb5ea87f639cab18b2a05b.45.llvm.3779847476987057767 │ │ │ │ │ +[12497](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000960 __imp_TlsAlloc │ │ │ │ │ +[12498](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006a78 anon.5188eecf01c48ed8fcadadd01fcebeeb.4.llvm.10386673973210777259 │ │ │ │ │ +[12499](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005b30 anon.2fc0b598515d6d45a6f7a748d37f9e68.41.llvm.9180192027238945235 │ │ │ │ │ +[12500](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001a3c __lib64_libuserenv_a_iname │ │ │ │ │ +[12501](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004bd8 anon.a43af9cc4981a42dd00b013f8f55f130.58.llvm.13665133684747362110 │ │ │ │ │ +[12502](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000980 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.65.llvm.4036729494550109879 │ │ │ │ │ +[12503](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000040e0 anon.ce6f0c62864fa439afba1682d1475d3d.49.llvm.14048921605721191922 │ │ │ │ │ +[12504](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008a0 _ZN3std3sys3pal7windows1c20SetThreadDescription3PTR17h62a2495fa6119c78E │ │ │ │ │ +[12505](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bc8 __imp_anon.3bd369ec61590d9272c591ac87029920.2.llvm.2123515186662715695 │ │ │ │ │ +[12506](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000738 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.117.llvm.13665133684747362110 │ │ │ │ │ +[12507](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c28 __imp_anon.9de54bf691a285dd20d4e87e6b508fbd.8.llvm.12123695082059135366 │ │ │ │ │ +[12508](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000080 anon.7ce35b53eeafc768de935b4fef3da959.3.llvm.1024159395525823541 │ │ │ │ │ +[12509](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000015c8 anon.03a7b1eb39947173efb71e48c5b540f4.52.llvm.10021583357862909 │ │ │ │ │ +[12510](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000038 __xl_c │ │ │ │ │ +[12511](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000e8 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.28.llvm.12196597439006139751 │ │ │ │ │ +[12512](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ec0 __imp__initialize_onexit_table │ │ │ │ │ +[12513](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009f8 __imp_abort │ │ │ │ │ +[12514](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000040 __xl_d │ │ │ │ │ +[12515](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000030b0 anon.edf9b0bdfd963b6a2ea99216811efd5e.85.llvm.65172163764165323 │ │ │ │ │ +[12516](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000029b0 anon.edf9b0bdfd963b6a2ea99216811efd5e.1.llvm.65172163764165323 │ │ │ │ │ +[12517](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003b80 anon.941f0f04b36aa440174d89d326747b6f.53.llvm.16620058351426711825 │ │ │ │ │ +[12518](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004ac0 anon.a43af9cc4981a42dd00b013f8f55f130.53.llvm.13665133684747362110 │ │ │ │ │ +[12519](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a678 WSADuplicateSocketW │ │ │ │ │ +[12520](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000029b0 anon.edf9b0bdfd963b6a2ea99216811efd5e.0.llvm.65172163764165323 │ │ │ │ │ +[12521](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002848 anon.2d4ed69d03b8b00b295e2865b118c80a.13.llvm.9587153679006429619 │ │ │ │ │ +[12522](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003980 anon.941f0f04b36aa440174d89d326747b6f.32.llvm.16620058351426711825 │ │ │ │ │ +[12523](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006bb8 anon.5188eecf01c48ed8fcadadd01fcebeeb.14.llvm.10386673973210777259 │ │ │ │ │ +[12524](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001ae4 libgcc_s_seh_1_dll_iname │ │ │ │ │ +[12525](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001384a anon.bb01d4b423a85a795a1692e8cd9c64e5.10.llvm.11285312269184381906 │ │ │ │ │ +[12526](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002280 anon.577344e6c4a90a10ff600a929dedcba7.53.llvm.11685822864145163790 │ │ │ │ │ +[12527](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000640 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.5.llvm.13665133684747362110 │ │ │ │ │ +[12528](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009b0 __imp_WideCharToMultiByte │ │ │ │ │ +[12529](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015118 anon.7a6259c55b9abecd4a2eb0873fc8b779.37.llvm.10283439849247210698 │ │ │ │ │ +[12530](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007f08 anon.75cd115d168aa5adc70873d7be22c67a.11.llvm.8768119154728042530 │ │ │ │ │ +[12531](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c31b8 ___DTOR_LIST__ │ │ │ │ │ +[12532](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a640 bind │ │ │ │ │ +[12533](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008e0 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.8.llvm.4036729494550109879 │ │ │ │ │ +[12534](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007c0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.19.llvm.9180192027238945235 │ │ │ │ │ +[12535](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006c00 anon.5188eecf01c48ed8fcadadd01fcebeeb.16.llvm.10386673973210777259 │ │ │ │ │ +[12536](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000028 __xl_a │ │ │ │ │ +[12537](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000a0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.9.llvm.12196597439006139751 │ │ │ │ │ +[12538](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000188 __native_startup_state │ │ │ │ │ +[12539](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a358 ReadFile │ │ │ │ │ +[12540](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b48 __imp_anon.c4d194f4cabed4ef9246cda43331cffc.4.llvm.6008810897942320446 │ │ │ │ │ +[12541](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000548 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.80.llvm.14048921605721191922 │ │ │ │ │ +[12542](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000698 __imp_CreateDirectoryW │ │ │ │ │ +[12543](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008a8 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.0.llvm.4036729494550109879 │ │ │ │ │ +[12544](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006c0 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.21.llvm.13665133684747362110 │ │ │ │ │ +[12545](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e58 __imp_anon.07b55acb663eb35d742bae824872f75e.32.llvm.58757282566773765 │ │ │ │ │ +[12546](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d30 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.71.llvm.10283439849247210698 │ │ │ │ │ +[12547](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000720 __imp_ExitProcess │ │ │ │ │ +[12548](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002588 anon.577344e6c4a90a10ff600a929dedcba7.83.llvm.11685822864145163790 │ │ │ │ │ +[12549](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ae0 __imp_anon.d13ef5d19e380ff1a25cb10df774bd92.2.llvm.13995198208019911955 │ │ │ │ │ +[12550](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001731d anon.df4f5fc91c1c1e84f2976758feaea474.17.llvm.17095335174290335670 │ │ │ │ │ +[12551](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000970 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.58.llvm.4036729494550109879 │ │ │ │ │ +[12552](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000e8 _ZN3std2rt7cleanup7CLEANUP17h07b9456e6b4bf964E.llvm.14048921605721191922 │ │ │ │ │ +[12553](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b18 __imp_ioctlsocket │ │ │ │ │ +[12554](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a418 GetOverlappedResult │ │ │ │ │ +[12555](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e00 __imp_anon.07b55acb663eb35d742bae824872f75e.21.llvm.58757282566773765 │ │ │ │ │ +[12556](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022ec0 __rt_psrelocs_end │ │ │ │ │ +[12557](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcf0 anon.07b55acb663eb35d742bae824872f75e.28.llvm.58757282566773765 │ │ │ │ │ +[12558](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008b8 __imp_ReadConsoleW │ │ │ │ │ +[12559](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000758 __imp_anon.71b4c3b3c7c90ed67c6b8e618b4d496a.1.llvm.14138378158770856212 │ │ │ │ │ +[12560](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006c8 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.22.llvm.13665133684747362110 │ │ │ │ │ +[12561](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001511f anon.7a6259c55b9abecd4a2eb0873fc8b779.38.llvm.10283439849247210698 │ │ │ │ │ +[12562](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c3130 __iob_func │ │ │ │ │ +[12563](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ad0 __imp_accept │ │ │ │ │ +[12564](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000020ce anon.577344e6c4a90a10ff600a929dedcba7.35.llvm.11685822864145163790 │ │ │ │ │ +[12565](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002570 anon.577344e6c4a90a10ff600a929dedcba7.82.llvm.11685822864145163790 │ │ │ │ │ +[12566](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a520 CreateThread │ │ │ │ │ +[12567](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000066f0 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.37.llvm.4036729494550109879 │ │ │ │ │ +[12568](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c3140 fwrite │ │ │ │ │ +[12569](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000378 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.4.llvm.65172163764165323 │ │ │ │ │ +[12570](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dba8 anon.07b55acb663eb35d742bae824872f75e.6.llvm.58757282566773765 │ │ │ │ │ +[12571](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cef anon.c5e06b7d2fb27e4271afbca860883ce8.29.llvm.12196597439006139751 │ │ │ │ │ +[12572](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015330 anon.7a6259c55b9abecd4a2eb0873fc8b779.69.llvm.10283439849247210698 │ │ │ │ │ +[12573](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013100 anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.0.llvm.12700038450165258506 │ │ │ │ │ +[12574](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000448 __imp_anon.941f0f04b36aa440174d89d326747b6f.14.llvm.16620058351426711825 │ │ │ │ │ +[12575](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a08 __imp_free │ │ │ │ │ +[12576](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000134c8 anon.3bd369ec61590d9272c591ac87029920.0.llvm.2123515186662715695 │ │ │ │ │ +[12577](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003918 anon.941f0f04b36aa440174d89d326747b6f.28.llvm.16620058351426711825 │ │ │ │ │ +[12578](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002a20 anon.edf9b0bdfd963b6a2ea99216811efd5e.4.llvm.65172163764165323 │ │ │ │ │ +[12579](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010d98 anon.567cec0599d353b04e33d4229b5f9b30.3.llvm.2628756017061842597 │ │ │ │ │ +[12580](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002b0 __imp__ZN3std10sys_common11thread_info11THREAD_INFO7__getit5__KEY17ha20a47e83639d552E.llvm.11685822864145163790 │ │ │ │ │ +[12581](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006240 anon.2fc0b598515d6d45a6f7a748d37f9e68.94.llvm.9180192027238945235 │ │ │ │ │ +[12582](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000028 __imp_anon.7ce35b53eeafc768de935b4fef3da959.11.llvm.1024159395525823541 │ │ │ │ │ +[12583](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000638 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.4.llvm.13665133684747362110 │ │ │ │ │ +[12584](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a330 RtlVirtualUnwind │ │ │ │ │ +[12585](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4c8 FlushFileBuffers │ │ │ │ │ +[12586](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004458 anon.ce6f0c62864fa439afba1682d1475d3d.80.llvm.14048921605721191922 │ │ │ │ │ +[12587](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000017300 anon.df4f5fc91c1c1e84f2976758feaea474.16.llvm.17095335174290335670 │ │ │ │ │ +[12588](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e70 anon.ce6f0c62864fa439afba1682d1475d3d.21.llvm.14048921605721191922 │ │ │ │ │ +[12589](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004d0 __imp__ZN3std3sys3pal7windows1c8KERNEL3217h9414b6c65f82effbE │ │ │ │ │ +[12590](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005738 anon.2fc0b598515d6d45a6f7a748d37f9e68.4.llvm.9180192027238945235 │ │ │ │ │ +[12591](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000103a0 anon.d13ef5d19e380ff1a25cb10df774bd92.4.llvm.13995198208019911955 │ │ │ │ │ +[12592](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a68 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.107.llvm.10386673973210777259 │ │ │ │ │ +[12593](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013c10 anon.1cd6cbb5d23cd003f709872fa6a8a6dd.30.llvm.9517595369394268439 │ │ │ │ │ +[12594](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003e0 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.85.llvm.65172163764165323 │ │ │ │ │ +[12595](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000408 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.116.llvm.65172163764165323 │ │ │ │ │ +[12596](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007c37 anon.5de116bb10f22f2f898f0999be20ad04.10.llvm.16857200617075268833 │ │ │ │ │ +[12597](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000780 __imp_GetCurrentThread │ │ │ │ │ +[12598](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a660 WSASend │ │ │ │ │ +[12599](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000b0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.22.llvm.12196597439006139751 │ │ │ │ │ +[12600](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009a0 __imp_WaitForMultipleObjects │ │ │ │ │ +[12601](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a38 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.101.llvm.10386673973210777259 │ │ │ │ │ +[12602](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000818 __imp_GetSystemDirectoryW │ │ │ │ │ +[12603](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000021e0 anon.577344e6c4a90a10ff600a929dedcba7.48.llvm.11685822864145163790 │ │ │ │ │ +[12604](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005590 anon.71b4c3b3c7c90ed67c6b8e618b4d496a.2.llvm.14138378158770856212 │ │ │ │ │ +[12605](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000047ee anon.a43af9cc4981a42dd00b013f8f55f130.5.llvm.13665133684747362110 │ │ │ │ │ +[12606](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000228 __imp_anon.577344e6c4a90a10ff600a929dedcba7.5.llvm.11685822864145163790 │ │ │ │ │ +[12607](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000062a4 anon.2fc0b598515d6d45a6f7a748d37f9e68.99.llvm.9180192027238945235 │ │ │ │ │ +[12608](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a320 SetEnvironmentVariableW │ │ │ │ │ +[12609](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006120 anon.2fc0b598515d6d45a6f7a748d37f9e68.86.llvm.9180192027238945235 │ │ │ │ │ +[12610](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000062b5 anon.2fc0b598515d6d45a6f7a748d37f9e68.101.llvm.9180192027238945235 │ │ │ │ │ +[12611](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015113 anon.7a6259c55b9abecd4a2eb0873fc8b779.35.llvm.10283439849247210698 │ │ │ │ │ +[12612](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000390 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.54.llvm.65172163764165323 │ │ │ │ │ +[12613](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003970 anon.941f0f04b36aa440174d89d326747b6f.31.llvm.16620058351426711825 │ │ │ │ │ +[12614](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005881 anon.2fc0b598515d6d45a6f7a748d37f9e68.17.llvm.9180192027238945235 │ │ │ │ │ +[12615](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006180 anon.2fc0b598515d6d45a6f7a748d37f9e68.88.llvm.9180192027238945235 │ │ │ │ │ +[12616](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a600 ioctlsocket │ │ │ │ │ +[12617](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006f68 anon.5188eecf01c48ed8fcadadd01fcebeeb.50.llvm.10386673973210777259 │ │ │ │ │ +[12618](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000840 anon.08c341bb7f186daefc16bdd18254cc9c.4.llvm.2852608270795916942 │ │ │ │ │ +[12619](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ca0 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.40.llvm.10283439849247210698 │ │ │ │ │ +[12620](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003c90 anon.ce6f0c62864fa439afba1682d1475d3d.0.llvm.14048921605721191922 │ │ │ │ │ +[12621](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000055f8 anon.71b4c3b3c7c90ed67c6b8e618b4d496a.6.llvm.14138378158770856212 │ │ │ │ │ +[12622](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000420 __imp_anon.941f0f04b36aa440174d89d326747b6f.6.llvm.16620058351426711825 │ │ │ │ │ +[12623](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ef0 _CRT_MT │ │ │ │ │ +[12624](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000648 __imp_WakeByAddressAll │ │ │ │ │ +[12625](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000980 __imp_UnmapViewOfFile │ │ │ │ │ +[12626](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000878 __imp_LeaveCriticalSection │ │ │ │ │ +[12627](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e28 __imp_anon.07b55acb663eb35d742bae824872f75e.26.llvm.58757282566773765 │ │ │ │ │ +[12628](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cc8 anon.c5e06b7d2fb27e4271afbca860883ce8.26.llvm.12196597439006139751 │ │ │ │ │ +[12629](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cb8 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.43.llvm.10283439849247210698 │ │ │ │ │ +[12630](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2b8 TlsAlloc │ │ │ │ │ +[12631](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3d8 GetTempPathW │ │ │ │ │ +[12632](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006279 anon.2fc0b598515d6d45a6f7a748d37f9e68.96.llvm.9180192027238945235 │ │ │ │ │ +[12633](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000171c0 anon.df4f5fc91c1c1e84f2976758feaea474.14.llvm.17095335174290335670 │ │ │ │ │ +[12634](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000dc0 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.21.llvm.17095335174290335670 │ │ │ │ │ +[12635](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000002 __minor_subsystem_version__ │ │ │ │ │ +[12636](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010e68 anon.567cec0599d353b04e33d4229b5f9b30.9.llvm.2628756017061842597 │ │ │ │ │ +[12637](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004e8 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.18.llvm.14048921605721191922 │ │ │ │ │ +[12638](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001268 anon.03a7b1eb39947173efb71e48c5b540f4.10.llvm.10021583357862909 │ │ │ │ │ +[12639](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000760 __imp_anon.71b4c3b3c7c90ed67c6b8e618b4d496a.2.llvm.14138378158770856212 │ │ │ │ │ +[12640](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000100000 __size_of_heap_reserve__ │ │ │ │ │ +[12641](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004877 anon.a43af9cc4981a42dd00b013f8f55f130.16.llvm.13665133684747362110 │ │ │ │ │ +[12642](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001396f anon.9de54bf691a285dd20d4e87e6b508fbd.9.llvm.12123695082059135366 │ │ │ │ │ +[12643](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4c0 FormatMessageW │ │ │ │ │ +[12644](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000016708 _ZN4core7unicode12unicode_data15grapheme_extend7OFFSETS17h442f9377d3be9cdfE.llvm.819651363561423643 │ │ │ │ │ +[12645](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2144 ProcessPrng │ │ │ │ │ +[12646](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000320 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.14.llvm.9587153679006429619 │ │ │ │ │ +[12647](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006b8 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.20.llvm.13665133684747362110 │ │ │ │ │ +[12648](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000b0 _ZN3std2io5stdio6stderr8INSTANCE17h050c730875ffdbc8E │ │ │ │ │ +[12649](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003930 anon.941f0f04b36aa440174d89d326747b6f.29.llvm.16620058351426711825 │ │ │ │ │ +[12650](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a338 RtlLookupFunctionEntry │ │ │ │ │ +[12651](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c40 .refptr.__xi_a │ │ │ │ │ +[12652](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a28 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.70.llvm.10386673973210777259 │ │ │ │ │ +[12653](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009c8 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.12.llvm.10386673973210777259 │ │ │ │ │ +[12654](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a50 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.104.llvm.10386673973210777259 │ │ │ │ │ +[12655](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000064 _head_lib64_libuserenv_a │ │ │ │ │ +[12656](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4d0 FindNextFileW │ │ │ │ │ +[12657](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003900 anon.941f0f04b36aa440174d89d326747b6f.27.llvm.16620058351426711825 │ │ │ │ │ +[12658](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c20 __imp_anon.9de54bf691a285dd20d4e87e6b508fbd.7.llvm.12123695082059135366 │ │ │ │ │ +[12659](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009f0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.46.llvm.10386673973210777259 │ │ │ │ │ +[12660](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cf8 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.64.llvm.10283439849247210698 │ │ │ │ │ +[12661](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d60 __imp_anon.8d718ed12c404e6593cdb19a2e5276ea.22.llvm.819651363561423643 │ │ │ │ │ +[12662](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000870 anon.08c341bb7f186daefc16bdd18254cc9c.6.llvm.2852608270795916942 │ │ │ │ │ +[12663](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000079d8 anon.b600da5f5c44c0dd2674915485b1c9f6.0.llvm.9103046057031032332 │ │ │ │ │ +[12664](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c50 .refptr.__xi_z │ │ │ │ │ +[12665](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a438 GetLastError │ │ │ │ │ +[12666](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000138 _ZN3std3sys3pal7windows5alloc4HEAP17h34e549f5a2364763E │ │ │ │ │ +[12667](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000428 __imp_anon.941f0f04b36aa440174d89d326747b6f.10.llvm.16620058351426711825 │ │ │ │ │ +[12668](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000b8 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.23.llvm.12196597439006139751 │ │ │ │ │ +[12669](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b60 __imp_anon.7ec0d7d1b51f482853d19890eaa43e99.0.llvm.4855701895496871646 │ │ │ │ │ +[12670](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000878 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.96.llvm.9180192027238945235 │ │ │ │ │ +[12671](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007f8 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.43.llvm.9180192027238945235 │ │ │ │ │ +[12672](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e60 __imp__ZN4core3num7dec2flt5table17POWER_OF_FIVE_12817h1308de4d59502321E │ │ │ │ │ +[12673](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b58 __imp_anon.d5e7fe67f7f67b071ebb27a2ce9d6115.0.llvm.16008337483328089059 │ │ │ │ │ +[12674](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006fa0 anon.5188eecf01c48ed8fcadadd01fcebeeb.52.llvm.10386673973210777259 │ │ │ │ │ +[12675](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000220 __imp_anon.577344e6c4a90a10ff600a929dedcba7.4.llvm.11685822864145163790 │ │ │ │ │ +[12676](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b78 __imp__Unwind_GetDataRelBase │ │ │ │ │ +[12677](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000308 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.7.llvm.9587153679006429619 │ │ │ │ │ +[12678](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000020f0 anon.577344e6c4a90a10ff600a929dedcba7.36.llvm.11685822864145163790 │ │ │ │ │ +[12679](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000028 _head_lib64_libkernel32_a │ │ │ │ │ +[12680](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006a38 anon.5188eecf01c48ed8fcadadd01fcebeeb.3.llvm.10386673973210777259 │ │ │ │ │ +[12681](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000728 __imp_FindClose │ │ │ │ │ +[12682](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000798 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.14.llvm.9180192027238945235 │ │ │ │ │ +[12683](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a560 CreateDirectoryW │ │ │ │ │ +[12684](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001288 anon.03a7b1eb39947173efb71e48c5b540f4.11.llvm.10021583357862909 │ │ │ │ │ +[12685](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000044d0 anon.ce6f0c62864fa439afba1682d1475d3d.84.llvm.14048921605721191922 │ │ │ │ │ +[12686](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000018 pcinit │ │ │ │ │ +[12687](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000860 __imp_InitOnceComplete │ │ │ │ │ +[12688](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000918 __imp_SetFileTime │ │ │ │ │ +[12689](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004430 anon.ce6f0c62864fa439afba1682d1475d3d.79.llvm.14048921605721191922 │ │ │ │ │ +[12690](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c3170 InitializeCriticalSection │ │ │ │ │ +[12691](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004b8 __imp_anon.941f0f04b36aa440174d89d326747b6f.58.llvm.16620058351426711825 │ │ │ │ │ +[12692](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ab0 anon.c5e06b7d2fb27e4271afbca860883ce8.7.llvm.12196597439006139751 │ │ │ │ │ +[12693](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000012f90 anon.7ec0d7d1b51f482853d19890eaa43e99.13.llvm.4855701895496871646 │ │ │ │ │ +[12694](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a70 __imp___rust_alloc_error_handler_should_panic │ │ │ │ │ +[12695](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000560 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.83.llvm.14048921605721191922 │ │ │ │ │ +[12696](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000de0 __imp_anon.07b55acb663eb35d742bae824872f75e.12.llvm.58757282566773765 │ │ │ │ │ +[12697](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000af0 __imp_anon.d13ef5d19e380ff1a25cb10df774bd92.4.llvm.13995198208019911955 │ │ │ │ │ +[12698](sec 11)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 _tls_start │ │ │ │ │ +[12699](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bb8 __imp__Unwind_SetIP │ │ │ │ │ +[12700](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000888 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.99.llvm.9180192027238945235 │ │ │ │ │ +[12701](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000002159e anon.d5fd6146a7cb5ea87f639cab18b2a05b.46.llvm.3779847476987057767 │ │ │ │ │ +[12702](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a558 CreateEventW │ │ │ │ │ +[12703](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000888 __imp_Module32FirstW │ │ │ │ │ +[12704](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a388 Module32NextW │ │ │ │ │ +[12705](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b50 __imp_anon.c4d194f4cabed4ef9246cda43331cffc.5.llvm.6008810897942320446 │ │ │ │ │ +[12706](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015132 anon.7a6259c55b9abecd4a2eb0873fc8b779.48.llvm.10283439849247210698 │ │ │ │ │ +[12707](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000001a0 __mingw_app_type │ │ │ │ │ +[12708](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e68 __imp__ZN4core7unicode12unicode_data11white_space14WHITESPACE_MAP17h6da2769d9619e572E │ │ │ │ │ +[12709](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004be8 anon.a43af9cc4981a42dd00b013f8f55f130.59.llvm.13665133684747362110 │ │ │ │ │ +[12710](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000778 __imp_GetCurrentProcessId │ │ │ │ │ +[12711](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5d8 send │ │ │ │ │ +[12712](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000200000 __size_of_stack_reserve__ │ │ │ │ │ +[12713](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c80 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.36.llvm.10283439849247210698 │ │ │ │ │ +[12714](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000568 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.84.llvm.14048921605721191922 │ │ │ │ │ +[12715](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002a48 anon.edf9b0bdfd963b6a2ea99216811efd5e.5.llvm.65172163764165323 │ │ │ │ │ +[12716](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009c0 __imp_WriteFileEx │ │ │ │ │ +[12717](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000df8 __imp_anon.07b55acb663eb35d742bae824872f75e.20.llvm.58757282566773765 │ │ │ │ │ +[12718](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000810 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.46.llvm.9180192027238945235 │ │ │ │ │ +[12719](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000648 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.6.llvm.13665133684747362110 │ │ │ │ │ +[12720](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e90 __imp_anon.d5fd6146a7cb5ea87f639cab18b2a05b.44.llvm.3779847476987057767 │ │ │ │ │ +[12721](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a298 UnmapViewOfFile │ │ │ │ │ +[12722](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002de0 anon.edf9b0bdfd963b6a2ea99216811efd5e.53.llvm.65172163764165323 │ │ │ │ │ +[12723](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcd0 anon.07b55acb663eb35d742bae824872f75e.26.llvm.58757282566773765 │ │ │ │ │ +[12724](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ee0 __native_vcclrit_reason │ │ │ │ │ +[12725](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a518 CreateToolhelp32Snapshot │ │ │ │ │ +[12726](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c88 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.37.llvm.10283439849247210698 │ │ │ │ │ +[12727](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a68 __imp_NtReadFile │ │ │ │ │ +[12728](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009e0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.15.llvm.10386673973210777259 │ │ │ │ │ +[12729](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a628 freeaddrinfo │ │ │ │ │ +[12730](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000081a8 anon.fc3e879c0d0583c039a7967db6c0c117.0.llvm.14670435032436802275 │ │ │ │ │ +[12731](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000028a8 anon.2d4ed69d03b8b00b295e2865b118c80a.16.llvm.9587153679006429619 │ │ │ │ │ +[12732](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000017050 anon.df4f5fc91c1c1e84f2976758feaea474.2.llvm.17095335174290335670 │ │ │ │ │ +[12733](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000700 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.59.llvm.13665133684747362110 │ │ │ │ │ +[12734](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000128 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.3.llvm.10021583357862909 │ │ │ │ │ +[12735](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000850 __imp_HeapReAlloc │ │ │ │ │ +[12736](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a08 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.49.llvm.10386673973210777259 │ │ │ │ │ +[12737](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000c8 anon.7ce35b53eeafc768de935b4fef3da959.4.llvm.1024159395525823541 │ │ │ │ │ +[12738](sec 0)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __end__ │ │ │ │ │ +[12739](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003c38 anon.941f0f04b36aa440174d89d326747b6f.60.llvm.16620058351426711825 │ │ │ │ │ +[12740](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e40 __imp_anon.07b55acb663eb35d742bae824872f75e.29.llvm.58757282566773765 │ │ │ │ │ +[12741](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005bb8 anon.2fc0b598515d6d45a6f7a748d37f9e68.46.llvm.9180192027238945235 │ │ │ │ │ +[12742](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000108 __imp_anon.2611162d579b3e706d0c0f15accb8ea6.2.llvm.17987727548992354187 │ │ │ │ │ +[12743](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cc0 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.44.llvm.10283439849247210698 │ │ │ │ │ +[12744](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000221a anon.577344e6c4a90a10ff600a929dedcba7.51.llvm.11685822864145163790 │ │ │ │ │ +[12745](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002158 anon.577344e6c4a90a10ff600a929dedcba7.41.llvm.11685822864145163790 │ │ │ │ │ +[12746](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007e88 anon.75cd115d168aa5adc70873d7be22c67a.7.llvm.8768119154728042530 │ │ │ │ │ +[12747](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bf0 __imp_anon.bb01d4b423a85a795a1692e8cd9c64e5.9.llvm.11285312269184381906 │ │ │ │ │ +[12748](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ba0 __imp__Unwind_RaiseException │ │ │ │ │ +[12749](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007b8 __imp_GetFileType │ │ │ │ │ +[12750](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009b8 __imp_WriteConsoleW │ │ │ │ │ +[12751](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007d8 __imp_GetModuleFileNameW │ │ │ │ │ +[12752](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006e8 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.54.llvm.13665133684747362110 │ │ │ │ │ +[12753](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000430 __imp_anon.941f0f04b36aa440174d89d326747b6f.11.llvm.16620058351426711825 │ │ │ │ │ +[12754](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b80 __imp_anon.ae9ea30a8e884eaaf6e7ec56ddc7bcd5.0.llvm.12700038450165258506 │ │ │ │ │ [12755](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006a0 __imp_CreateEventW │ │ │ │ │ [12756](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ce8 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.49.llvm.10283439849247210698 │ │ │ │ │ [12757](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcc8 anon.07b55acb663eb35d742bae824872f75e.21.llvm.58757282566773765 │ │ │ │ │ [12758](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c3180 DeleteCriticalSection │ │ │ │ │ [12759](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000046e0 anon.ce6f0c62864fa439afba1682d1475d3d.115.llvm.14048921605721191922 │ │ │ │ │ [12760](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001512b anon.7a6259c55b9abecd4a2eb0873fc8b779.42.llvm.10283439849247210698 │ │ │ │ │ [12761](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2f0 SetLastError │ │ │ │ │ @@ -37128,496 +37128,496 @@ │ │ │ │ │ [12784](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000990 __imp__ZN3std3sys3pal7windows1c20SetThreadDescription3PTR17h62a2495fa6119c78E │ │ │ │ │ [12785](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcb0 anon.07b55acb663eb35d742bae824872f75e.20.llvm.58757282566773765 │ │ │ │ │ [12786](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003240 anon.edf9b0bdfd963b6a2ea99216811efd5e.111.llvm.65172163764165323 │ │ │ │ │ [12787](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000770 __imp_GetCurrentProcess │ │ │ │ │ [12788](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000012990 anon.c4d194f4cabed4ef9246cda43331cffc.5.llvm.6008810897942320446 │ │ │ │ │ [12789](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2e0 SetWaitableTimer │ │ │ │ │ [12790](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008a0 __imp_MultiByteToWideChar │ │ │ │ │ -[12791](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000017370 anon.df4f5fc91c1c1e84f2976758feaea474.20.llvm.17095335174290335670 │ │ │ │ │ -[12792](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009e8 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.16.llvm.10386673973210777259 │ │ │ │ │ -[12793](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013920 anon.9de54bf691a285dd20d4e87e6b508fbd.6.llvm.12123695082059135366 │ │ │ │ │ -[12794](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008c8 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.6.llvm.4036729494550109879 │ │ │ │ │ -[12795](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000128 _ZN3std6thread8ThreadId3new7COUNTER17hf61725333ea7cf69E.llvm.13665133684747362110 │ │ │ │ │ -[12796](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000152d8 anon.7a6259c55b9abecd4a2eb0873fc8b779.65.llvm.10283439849247210698 │ │ │ │ │ -[12797](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2188 _Unwind_RaiseException │ │ │ │ │ -[12798](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c2350 calloc │ │ │ │ │ -[12799](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000868 __imp_InitializeCriticalSection │ │ │ │ │ -[12800](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000730 __imp_FindFirstFileW │ │ │ │ │ -[12801](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000db8 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.20.llvm.17095335174290335670 │ │ │ │ │ -[12802](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003078 anon.edf9b0bdfd963b6a2ea99216811efd5e.81.llvm.65172163764165323 │ │ │ │ │ -[12803](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004778 anon.ce6f0c62864fa439afba1682d1475d3d.121.llvm.14048921605721191922 │ │ │ │ │ -[12804](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000010 ___crt_xi_start__ │ │ │ │ │ -[12805](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000090 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.7.llvm.12196597439006139751 │ │ │ │ │ -[12806](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015378 anon.7a6259c55b9abecd4a2eb0873fc8b779.72.llvm.10283439849247210698 │ │ │ │ │ -[12807](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007478 anon.5188eecf01c48ed8fcadadd01fcebeeb.104.llvm.10386673973210777259 │ │ │ │ │ -[12808](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000307c anon.edf9b0bdfd963b6a2ea99216811efd5e.82.llvm.65172163764165323 │ │ │ │ │ -[12809](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002b8 __imp__ZN3std4sync14reentrant_lock25current_thread_unique_ptr1X7__getit5__KEY17h077daefc5f25ce95E.llvm.11685822864145163790 │ │ │ │ │ -[12810](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2170 _Unwind_SetIP │ │ │ │ │ -[12811](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a58 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.106.llvm.10386673973210777259 │ │ │ │ │ -[12812](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000840 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.88.llvm.9180192027238945235 │ │ │ │ │ -[12813](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006648 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.31.llvm.4036729494550109879 │ │ │ │ │ -[12814](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b40 __imp_anon.c4d194f4cabed4ef9246cda43331cffc.3.llvm.6008810897942320446 │ │ │ │ │ -[12815](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002a0 __imp_anon.577344e6c4a90a10ff600a929dedcba7.84.llvm.11685822864145163790 │ │ │ │ │ -[12816](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcca anon.07b55acb663eb35d742bae824872f75e.24.llvm.58757282566773765 │ │ │ │ │ -[12817](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004c0 __imp_anon.941f0f04b36aa440174d89d326747b6f.59.llvm.16620058351426711825 │ │ │ │ │ -[12818](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000011c8 anon.03a7b1eb39947173efb71e48c5b540f4.5.llvm.10021583357862909 │ │ │ │ │ -[12819](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e4f anon.ce6f0c62864fa439afba1682d1475d3d.19.llvm.14048921605721191922 │ │ │ │ │ -[12820](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000570 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.115.llvm.14048921605721191922 │ │ │ │ │ -[12821](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000af8 anon.c5e06b7d2fb27e4271afbca860883ce8.10.llvm.12196597439006139751 │ │ │ │ │ -[12822](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000748 __imp__ZN3std4sync4mpmc5waker17current_thread_id5DUMMY7__getit5__KEY17h8fc5a22a2d7694d4E.llvm.13665133684747362110 │ │ │ │ │ -[12823](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008d8 __imp_str.0.llvm.4036729494550109879 │ │ │ │ │ -[12824](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015125 anon.7a6259c55b9abecd4a2eb0873fc8b779.39.llvm.10283439849247210698 │ │ │ │ │ -[12825](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a608 getsockopt │ │ │ │ │ -[12826](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006790 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.42.llvm.4036729494550109879 │ │ │ │ │ -[12827](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000668 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.10.llvm.13665133684747362110 │ │ │ │ │ -[12828](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006392 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.9.llvm.4036729494550109879 │ │ │ │ │ -[12829](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000005 __major_subsystem_version__ │ │ │ │ │ -[12830](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006710 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.38.llvm.4036729494550109879 │ │ │ │ │ -[12831](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000820 __imp_GetSystemInfo │ │ │ │ │ -[12832](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002d8 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.1.llvm.9587153679006429619 │ │ │ │ │ -[12833](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000012930 anon.c4d194f4cabed4ef9246cda43331cffc.2.llvm.6008810897942320446 │ │ │ │ │ -[12834](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006b0 __imp_CreateFileW │ │ │ │ │ -[12835](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2b0 TlsFree │ │ │ │ │ -[12836](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a368 QueryPerformanceFrequency │ │ │ │ │ -[12837](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006f50 anon.5188eecf01c48ed8fcadadd01fcebeeb.49.llvm.10386673973210777259 │ │ │ │ │ -[12838](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d20 anon.2611162d579b3e706d0c0f15accb8ea6.0.llvm.17987727548992354187 │ │ │ │ │ -[12839](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010358 anon.d13ef5d19e380ff1a25cb10df774bd92.3.llvm.13995198208019911955 │ │ │ │ │ -[12840](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c10 .refptr.__rust_alloc_error_handler_should_panic │ │ │ │ │ -[12841](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006a8 __imp_CreateFileMappingA │ │ │ │ │ -[12842](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000db0 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.19.llvm.17095335174290335670 │ │ │ │ │ -[12843](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000628 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.2.llvm.13665133684747362110 │ │ │ │ │ -[12844](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000838 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.87.llvm.9180192027238945235 │ │ │ │ │ -[12845](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000140 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.8.llvm.10021583357862909 │ │ │ │ │ -[12846](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000240 __imp__ZN3std2io5stdio6STDOUT17h54404b6e0dbb130cE.llvm.11685822864145163790 │ │ │ │ │ -[12847](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003c8 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.82.llvm.65172163764165323 │ │ │ │ │ -[12848](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000152c8 anon.7a6259c55b9abecd4a2eb0873fc8b779.64.llvm.10283439849247210698 │ │ │ │ │ -[12849](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2e8 SetThreadStackGuarantee │ │ │ │ │ -[12850](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006e0 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.53.llvm.13665133684747362110 │ │ │ │ │ -[12851](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000af0 __imp_freeaddrinfo │ │ │ │ │ -[12852](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009b0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.3.llvm.10386673973210777259 │ │ │ │ │ -[12853](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a348 RemoveDirectoryW │ │ │ │ │ -[12854](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a468 GetFileAttributesW │ │ │ │ │ -[12855](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3a0 InitializeProcThreadAttributeList │ │ │ │ │ -[12856](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d70 __imp__ZN4core7unicode12unicode_data15grapheme_extend17SHORT_OFFSET_RUNS17hcc65fb30137b448cE.llvm.819651363561423643 │ │ │ │ │ -[12857](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002260 anon.577344e6c4a90a10ff600a929dedcba7.52.llvm.11685822864145163790 │ │ │ │ │ -[12858](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000778 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.10.llvm.9180192027238945235 │ │ │ │ │ -[12859](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006b78 anon.5188eecf01c48ed8fcadadd01fcebeeb.12.llvm.10386673973210777259 │ │ │ │ │ -[12860](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c50 __imp__ZN4core3num7flt2dec8strategy5grisu12CACHED_POW1017hc29b3bf8237d228dE │ │ │ │ │ -[12861](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008d0 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.7.llvm.4036729494550109879 │ │ │ │ │ -[12862](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000120 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.2.llvm.10021583357862909 │ │ │ │ │ -[12863](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d50 anon.2611162d579b3e706d0c0f15accb8ea6.1.llvm.17987727548992354187 │ │ │ │ │ -[12864](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000768 __imp_anon.71b4c3b3c7c90ed67c6b8e618b4d496a.6.llvm.14138378158770856212 │ │ │ │ │ -[12865](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a378 MultiByteToWideChar │ │ │ │ │ -[12866](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000728 __imp__ZN3std6thread8ThreadId3new7COUNTER17hf61725333ea7cf69E.llvm.13665133684747362110 │ │ │ │ │ -[12867](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000050 ___crt_xt_end__ │ │ │ │ │ -[12868](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b00 __imp_getpeername │ │ │ │ │ -[12869](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b70 __imp__Unwind_DeleteException │ │ │ │ │ -[12870](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000298 __imp_anon.577344e6c4a90a10ff600a929dedcba7.83.llvm.11685822864145163790 │ │ │ │ │ -[12871](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000001a8 _ZN3std10sys_common11thread_info11THREAD_INFO7__getit5__KEY17ha20a47e83639d552E.llvm.11685822864145163790 │ │ │ │ │ -[12872](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013c18 anon.1cd6cbb5d23cd003f709872fa6a8a6dd.31.llvm.9517595369394268439 │ │ │ │ │ -[12873](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e14 anon.ce6f0c62864fa439afba1682d1475d3d.18.llvm.14048921605721191922 │ │ │ │ │ -[12874](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3b0 InitOnceBeginInitialize │ │ │ │ │ -[12875](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000017200 anon.df4f5fc91c1c1e84f2976758feaea474.15.llvm.17095335174290335670 │ │ │ │ │ -[12876](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000047a8 anon.a43af9cc4981a42dd00b013f8f55f130.0.llvm.13665133684747362110 │ │ │ │ │ -[12877](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a650 WSAStartup │ │ │ │ │ -[12878](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ae0 anon.c5e06b7d2fb27e4271afbca860883ce8.9.llvm.12196597439006139751 │ │ │ │ │ -[12879](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000050 ___crt_xt_start__ │ │ │ │ │ -[12880](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000165d8 anon.8d718ed12c404e6593cdb19a2e5276ea.23.llvm.819651363561423643 │ │ │ │ │ -[12881](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022ec0 ___RUNTIME_PSEUDO_RELOC_LIST__ │ │ │ │ │ -[12882](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2198 _Unwind_GetRegionStart │ │ │ │ │ -[12883](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000828 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.85.llvm.9180192027238945235 │ │ │ │ │ -[12884](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000067e8 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.45.llvm.4036729494550109879 │ │ │ │ │ -[12885](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000016684 _ZN4core7unicode12unicode_data15grapheme_extend17SHORT_OFFSET_RUNS17hcc65fb30137b448cE.llvm.819651363561423643 │ │ │ │ │ -[12886](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a470 GetExitCodeProcess │ │ │ │ │ -[12887](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002740 anon.2d4ed69d03b8b00b295e2865b118c80a.4.llvm.9587153679006429619 │ │ │ │ │ -[12888](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000026d0 anon.2d4ed69d03b8b00b295e2865b118c80a.0.llvm.9587153679006429619 │ │ │ │ │ -[12889](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000152f8 anon.7a6259c55b9abecd4a2eb0873fc8b779.66.llvm.10283439849247210698 │ │ │ │ │ -[12890](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000708 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.65.llvm.13665133684747362110 │ │ │ │ │ -[12891](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000698 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.16.llvm.13665133684747362110 │ │ │ │ │ -[12892](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ac0 __imp_WSASocketW │ │ │ │ │ -[12893](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000078 _head_lib64_libws2_32_a │ │ │ │ │ -[12894](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a308 SetFilePointerEx │ │ │ │ │ -[12895](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015928 anon.d59256ba366f0704cef723753273bccf.6.llvm.4660425447921612699 │ │ │ │ │ -[12896](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __major_image_version__ │ │ │ │ │ -[12897](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001000 __section_alignment__ │ │ │ │ │ -[12898](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000068 __imp_anon.08c341bb7f186daefc16bdd18254cc9c.7.llvm.2852608270795916942 │ │ │ │ │ -[12899](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3e8 GetSystemInfo │ │ │ │ │ -[12900](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007438 anon.5188eecf01c48ed8fcadadd01fcebeeb.101.llvm.10386673973210777259 │ │ │ │ │ -[12901](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010ed0 anon.567cec0599d353b04e33d4229b5f9b30.12.llvm.2628756017061842597 │ │ │ │ │ -[12902](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000660 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.9.llvm.13665133684747362110 │ │ │ │ │ -[12903](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000908 __imp_SetFileInformationByHandle │ │ │ │ │ -[12904](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004468 anon.ce6f0c62864fa439afba1682d1475d3d.81.llvm.14048921605721191922 │ │ │ │ │ -[12905](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003750 anon.941f0f04b36aa440174d89d326747b6f.13.llvm.16620058351426711825 │ │ │ │ │ -[12906](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000858 anon.08c341bb7f186daefc16bdd18254cc9c.5.llvm.2852608270795916942 │ │ │ │ │ -[12907](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000a8 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.10.llvm.12196597439006139751 │ │ │ │ │ -[12908](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d90 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.15.llvm.17095335174290335670 │ │ │ │ │ -[12909](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000100 __imp_anon.2611162d579b3e706d0c0f15accb8ea6.1.llvm.17987727548992354187 │ │ │ │ │ -[12910](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006210 anon.2fc0b598515d6d45a6f7a748d37f9e68.92.llvm.9180192027238945235 │ │ │ │ │ -[12911](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000250 __imp_anon.577344e6c4a90a10ff600a929dedcba7.36.llvm.11685822864145163790 │ │ │ │ │ -[12912](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008f0 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.10.llvm.4036729494550109879 │ │ │ │ │ -[12913](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000048bb anon.a43af9cc4981a42dd00b013f8f55f130.21.llvm.13665133684747362110 │ │ │ │ │ -[12914](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a510 CreateWaitableTimerExW │ │ │ │ │ -[12915](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002868 anon.2d4ed69d03b8b00b295e2865b118c80a.14.llvm.9587153679006429619 │ │ │ │ │ -[12916](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000500 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.21.llvm.14048921605721191922 │ │ │ │ │ -[12917](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000678 __imp_CancelIo │ │ │ │ │ -[12918](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008c0 __imp_ReadFile │ │ │ │ │ -[12919](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000260 __imp__ZN3std2io5stdio6stderr8INSTANCE17h050c730875ffdbc8E │ │ │ │ │ -[12920](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ac0 __imp_anon.75cd115d168aa5adc70873d7be22c67a.11.llvm.8768119154728042530 │ │ │ │ │ -[12921](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000520 __imp__ZN3std10sys_common9backtrace4lock4LOCK17h96194423af38a9eeE.llvm.14048921605721191922 │ │ │ │ │ -[12922](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000540 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.79.llvm.14048921605721191922 │ │ │ │ │ -[12923](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a458 GetFileInformationByHandleEx │ │ │ │ │ -[12924](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c00 .refptr.__native_startup_state │ │ │ │ │ -[12925](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4a0 GetCurrentDirectoryW │ │ │ │ │ -[12926](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000930 __imp_SetThreadStackGuarantee │ │ │ │ │ -[12927](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dc80 anon.07b55acb663eb35d742bae824872f75e.19.llvm.58757282566773765 │ │ │ │ │ -[12928](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2190 _Unwind_GetTextRelBase │ │ │ │ │ -[12929](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000081d8 anon.fc3e879c0d0583c039a7967db6c0c117.1.llvm.14670435032436802275 │ │ │ │ │ -[12930](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001654b anon.8d718ed12c404e6593cdb19a2e5276ea.18.llvm.819651363561423643 │ │ │ │ │ -[12931](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000028 ___crt_xl_start__ │ │ │ │ │ -[12932](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005548 anon.71b4c3b3c7c90ed67c6b8e618b4d496a.0.llvm.14138378158770856212 │ │ │ │ │ -[12933](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c31b8 __DTOR_LIST__ │ │ │ │ │ -[12934](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004b20 anon.a43af9cc4981a42dd00b013f8f55f130.54.llvm.13665133684747362110 │ │ │ │ │ -[12935](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008d8 __imp_RtlCaptureContext │ │ │ │ │ -[12936](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000f0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.29.llvm.12196597439006139751 │ │ │ │ │ -[12937](sec 4)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 rust_metadata_std_9f917a5e7a74ff1 │ │ │ │ │ -[12938](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006f0 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.57.llvm.13665133684747362110 │ │ │ │ │ -[12939](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a450 GetFileType │ │ │ │ │ -[12940](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a408 GetProcessHeap │ │ │ │ │ -[12941](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a40 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.102.llvm.10386673973210777259 │ │ │ │ │ -[12942](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000be8 __imp_anon.bb01d4b423a85a795a1692e8cd9c64e5.2.llvm.11285312269184381906 │ │ │ │ │ -[12943](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000062c0 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.1.llvm.4036729494550109879 │ │ │ │ │ -[12944](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a18 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.51.llvm.10386673973210777259 │ │ │ │ │ -[12945](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000960 __imp__ZN3std3sys3pal7windows5alloc4HEAP17h34e549f5a2364763E │ │ │ │ │ -[12946](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008c8 __imp_ReadFileEx │ │ │ │ │ -[12947](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000400 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.111.llvm.65172163764165323 │ │ │ │ │ -[12948](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000047e0 anon.a43af9cc4981a42dd00b013f8f55f130.4.llvm.13665133684747362110 │ │ │ │ │ -[12949](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004a0 __imp_anon.941f0f04b36aa440174d89d326747b6f.53.llvm.16620058351426711825 │ │ │ │ │ -[12950](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000590 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.119.llvm.14048921605721191922 │ │ │ │ │ -[12951](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dc68 anon.07b55acb663eb35d742bae824872f75e.18.llvm.58757282566773765 │ │ │ │ │ -[12952](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __bss_start__ │ │ │ │ │ -[12953](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c3160 VirtualProtect │ │ │ │ │ -[12954](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e30 __imp_anon.07b55acb663eb35d742bae824872f75e.27.llvm.58757282566773765 │ │ │ │ │ -[12955](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000134c8 anon.3bd369ec61590d9272c591ac87029920.1.llvm.2123515186662715695 │ │ │ │ │ -[12956](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000071d8 anon.5188eecf01c48ed8fcadadd01fcebeeb.71.llvm.10386673973210777259 │ │ │ │ │ -[12957](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000518 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.49.llvm.14048921605721191922 │ │ │ │ │ -[12958](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000550 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.81.llvm.14048921605721191922 │ │ │ │ │ -[12959](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003d0 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.83.llvm.65172163764165323 │ │ │ │ │ -[12960](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5c8 setsockopt │ │ │ │ │ -[12961](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006740 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.40.llvm.4036729494550109879 │ │ │ │ │ -[12962](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000017d0 ___tmp_rustcBv6EAf_api_ms_win_core_synch_l1_2_0_lib_iname │ │ │ │ │ -[12963](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007e0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.40.llvm.9180192027238945235 │ │ │ │ │ -[12964](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000650 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.7.llvm.13665133684747362110 │ │ │ │ │ -[12965](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d40 __imp_anon.d59256ba366f0704cef723753273bccf.6.llvm.4660425447921612699 │ │ │ │ │ -[12966](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007a50 anon.e2378e14a3ab6920970de912c40858fb.1.llvm.12155384279649763508 │ │ │ │ │ -[12967](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004886 anon.a43af9cc4981a42dd00b013f8f55f130.17.llvm.13665133684747362110 │ │ │ │ │ -[12968](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ce0 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.48.llvm.10283439849247210698 │ │ │ │ │ -[12969](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a88 __imp_GetUserProfileDirectoryW │ │ │ │ │ -[12970](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022bb0 .refptr.__dyn_tls_init_callback │ │ │ │ │ -[12971](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000690 __imp_CopyFileExW │ │ │ │ │ -[12972](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000700 __imp_DeleteProcThreadAttributeList │ │ │ │ │ -[12973](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002c8 __imp__ZN3std9panicking11panic_count18GLOBAL_PANIC_COUNT17h5b40b3f81b5486b3E │ │ │ │ │ -[12974](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000dc8 __imp_anon.07b55acb663eb35d742bae824872f75e.1.llvm.58757282566773765 │ │ │ │ │ -[12975](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009c0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.11.llvm.10386673973210777259 │ │ │ │ │ -[12976](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000581c anon.2fc0b598515d6d45a6f7a748d37f9e68.13.llvm.9180192027238945235 │ │ │ │ │ -[12977](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000070 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.0.llvm.12196597439006139751 │ │ │ │ │ -[12978](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000027c0 anon.2d4ed69d03b8b00b295e2865b118c80a.7.llvm.9587153679006429619 │ │ │ │ │ -[12979](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __minor_image_version__ │ │ │ │ │ -[12980](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000838 __imp_GetWindowsDirectoryW │ │ │ │ │ -[12981](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dd08 anon.07b55acb663eb35d742bae824872f75e.29.llvm.58757282566773765 │ │ │ │ │ -[12982](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007d0 __imp_GetLastError │ │ │ │ │ -[12983](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002e48 anon.edf9b0bdfd963b6a2ea99216811efd5e.55.llvm.65172163764165323 │ │ │ │ │ -[12984](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000071b0 anon.5188eecf01c48ed8fcadadd01fcebeeb.70.llvm.10386673973210777259 │ │ │ │ │ -[12985](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000010 __imp_anon.7ce35b53eeafc768de935b4fef3da959.2.llvm.1024159395525823541 │ │ │ │ │ -[12986](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000880 __imp_MapViewOfFile │ │ │ │ │ -[12987](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000168 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.51.llvm.10021583357862909 │ │ │ │ │ -[12988](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009d0 anon.c5e06b7d2fb27e4271afbca860883ce8.0.llvm.12196597439006139751 │ │ │ │ │ -[12989](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000880 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.97.llvm.9180192027238945235 │ │ │ │ │ -[12990](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007b8 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.18.llvm.9180192027238945235 │ │ │ │ │ -[12991](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000050 ___crt_xp_end__ │ │ │ │ │ -[12992](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ae8 __imp_anon.d13ef5d19e380ff1a25cb10df774bd92.3.llvm.13995198208019911955 │ │ │ │ │ -[12993](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000048cd anon.a43af9cc4981a42dd00b013f8f55f130.22.llvm.13665133684747362110 │ │ │ │ │ -[12994](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000578 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.116.llvm.14048921605721191922 │ │ │ │ │ -[12995](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000018 __imp_anon.7ce35b53eeafc768de935b4fef3da959.3.llvm.1024159395525823541 │ │ │ │ │ -[12996](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c58 __imp__ZN4core3fmt2rt12USIZE_MARKER17hd232ed6d40ac3ff2E │ │ │ │ │ -[12997](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000020 __imp_anon.7ce35b53eeafc768de935b4fef3da959.4.llvm.1024159395525823541 │ │ │ │ │ -[12998](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000990 __imp_VirtualProtect │ │ │ │ │ -[12999](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006d8 __imp_CreateThread │ │ │ │ │ -[13000](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000388 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.53.llvm.65172163764165323 │ │ │ │ │ -[13001](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b00 __imp_anon.567cec0599d353b04e33d4229b5f9b30.4.llvm.2628756017061842597 │ │ │ │ │ -[13002](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a70 __imp_NtWriteFile │ │ │ │ │ -[13003](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000020ad0 anon.34ba7072d2fdbfb72b844525ea0f1e7b.0.llvm.3215435228619338225 │ │ │ │ │ -[13004](sec 11)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 ___tls_start__ │ │ │ │ │ -[13005](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ca8 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.41.llvm.10283439849247210698 │ │ │ │ │ -[13006](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000038 __imp_anon.08c341bb7f186daefc16bdd18254cc9c.0.llvm.2852608270795916942 │ │ │ │ │ -[13007](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a460 GetFileInformationByHandle │ │ │ │ │ -[13008](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a618 getpeername │ │ │ │ │ -[13009](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001a2c __lib64_libntdll_a_iname │ │ │ │ │ -[13010](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002fe8 anon.edf9b0bdfd963b6a2ea99216811efd5e.76.llvm.65172163764165323 │ │ │ │ │ -[13011](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000f0 _ZN3std10sys_common9backtrace4lock4LOCK17h96194423af38a9eeE.llvm.14048921605721191922 │ │ │ │ │ -[13012](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000800 __imp_GetProcessHeap │ │ │ │ │ -[13013](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000074c8 anon.5188eecf01c48ed8fcadadd01fcebeeb.107.llvm.10386673973210777259 │ │ │ │ │ -[13014](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007b0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.17.llvm.9180192027238945235 │ │ │ │ │ -[13015](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cf0 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.50.llvm.10283439849247210698 │ │ │ │ │ -[13016](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000278 __imp_anon.577344e6c4a90a10ff600a929dedcba7.52.llvm.11685822864145163790 │ │ │ │ │ -[13017](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a48 __imp_strncmp │ │ │ │ │ -[13018](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001eb0 anon.577344e6c4a90a10ff600a929dedcba7.6.llvm.11685822864145163790 │ │ │ │ │ -[13019](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000470 __imp_anon.941f0f04b36aa440174d89d326747b6f.30.llvm.16620058351426711825 │ │ │ │ │ -[13020](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000978 __imp_TlsSetValue │ │ │ │ │ -[13021](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000790 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.13.llvm.9180192027238945235 │ │ │ │ │ -[13022](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009d8 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.14.llvm.10386673973210777259 │ │ │ │ │ -[13023](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000047d5 anon.a43af9cc4981a42dd00b013f8f55f130.3.llvm.13665133684747362110 │ │ │ │ │ -[13024](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022b90 .refptr.__RUNTIME_PSEUDO_RELOC_LIST_END__ │ │ │ │ │ -[13025](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000019c _tls_index │ │ │ │ │ -[13026](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000650 __imp_WakeByAddressSingle │ │ │ │ │ -[13027](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cb0 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.42.llvm.10283439849247210698 │ │ │ │ │ -[13028](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007f8 anon.08c341bb7f186daefc16bdd18254cc9c.3.llvm.2852608270795916942 │ │ │ │ │ -[13029](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b38 __imp_anon.c4d194f4cabed4ef9246cda43331cffc.2.llvm.6008810897942320446 │ │ │ │ │ -[13030](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009a0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.1.llvm.10386673973210777259 │ │ │ │ │ -[13031](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000486b anon.a43af9cc4981a42dd00b013f8f55f130.15.llvm.13665133684747362110 │ │ │ │ │ -[13032](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007d0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.21.llvm.9180192027238945235 │ │ │ │ │ -[13033](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000928 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.38.llvm.4036729494550109879 │ │ │ │ │ -[13034](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007e0 __imp_GetModuleHandleA │ │ │ │ │ -[13035](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006f28 anon.5188eecf01c48ed8fcadadd01fcebeeb.48.llvm.10386673973210777259 │ │ │ │ │ -[13036](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a28 __imp_memmove │ │ │ │ │ -[13037](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000410 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.117.llvm.65172163764165323 │ │ │ │ │ -[13038](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003c0 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.81.llvm.65172163764165323 │ │ │ │ │ -[13039](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e10 __imp_anon.07b55acb663eb35d742bae824872f75e.23.llvm.58757282566773765 │ │ │ │ │ -[13040](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3f8 GetStdHandle │ │ │ │ │ -[13041](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000640 __IAT_start__ │ │ │ │ │ -[13042](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b28 __imp__ZN10std_detect6detect5cache5CACHE17hf632556ed460aa26E │ │ │ │ │ -[13043](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000708 __imp_DeviceIoControl │ │ │ │ │ -[13044](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000010 ___crt_xc_end__ │ │ │ │ │ -[13045](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c31a0 __CTOR_LIST__ │ │ │ │ │ -[13046](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004835 anon.a43af9cc4981a42dd00b013f8f55f130.11.llvm.13665133684747362110 │ │ │ │ │ -[13047](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000080 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.2.llvm.12196597439006139751 │ │ │ │ │ -[13048](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001228 anon.03a7b1eb39947173efb71e48c5b540f4.8.llvm.10021583357862909 │ │ │ │ │ -[13049](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d28 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.70.llvm.10283439849247210698 │ │ │ │ │ -[13050](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2a0 TlsSetValue │ │ │ │ │ -[13051](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000798 __imp_GetExitCodeProcess │ │ │ │ │ -[13052](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009d0 __imp___iob_func │ │ │ │ │ -[13053](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000848 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.89.llvm.9180192027238945235 │ │ │ │ │ -[13054](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015158 anon.7a6259c55b9abecd4a2eb0873fc8b779.50.llvm.10283439849247210698 │ │ │ │ │ -[13055](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __data_start__ │ │ │ │ │ -[13056](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006728 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.39.llvm.4036729494550109879 │ │ │ │ │ -[13057](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002600 anon.577344e6c4a90a10ff600a929dedcba7.84.llvm.11685822864145163790 │ │ │ │ │ -[13058](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000830 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.86.llvm.9180192027238945235 │ │ │ │ │ -[13059](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000005e0 _ZN3std4sync4mpmc5waker17current_thread_id5DUMMY7__getit5__KEY17h8fc5a22a2d7694d4E.llvm.13665133684747362110 │ │ │ │ │ -[13060](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3a8 InitOnceComplete │ │ │ │ │ -[13061](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5b0 GetUserProfileDirectoryW │ │ │ │ │ -[13062](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006f10 anon.5188eecf01c48ed8fcadadd01fcebeeb.47.llvm.10386673973210777259 │ │ │ │ │ -[13063](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c2338 _initterm │ │ │ │ │ -[13064](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a10 __imp_fwrite │ │ │ │ │ -[13065](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5d0 sendto │ │ │ │ │ -[13066](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004ba0 anon.a43af9cc4981a42dd00b013f8f55f130.57.llvm.13665133684747362110 │ │ │ │ │ -[13067](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007b0 anon.08c341bb7f186daefc16bdd18254cc9c.0.llvm.2852608270795916942 │ │ │ │ │ -[13068](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a50 __imp_vfprintf │ │ │ │ │ -[13069](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2150 WakeByAddressSingle │ │ │ │ │ -[13070](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3b8 HeapReAlloc │ │ │ │ │ -[13071](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bd8 __imp_anon.3bd369ec61590d9272c591ac87029920.6.llvm.2123515186662715695 │ │ │ │ │ -[13072](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000008c _head_libgcc_s_seh_1_dll │ │ │ │ │ -[13073](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000268 __imp_anon.577344e6c4a90a10ff600a929dedcba7.48.llvm.11685822864145163790 │ │ │ │ │ -[13074](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000558 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.82.llvm.14048921605721191922 │ │ │ │ │ -[13075](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000aa8 __imp_WSAGetLastError │ │ │ │ │ -[13076](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c08 __imp_anon.9de54bf691a285dd20d4e87e6b508fbd.5.llvm.12123695082059135366 │ │ │ │ │ -[13077](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006b0 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.19.llvm.13665133684747362110 │ │ │ │ │ -[13078](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ea0 __imp_anon.d5fd6146a7cb5ea87f639cab18b2a05b.46.llvm.3779847476987057767 │ │ │ │ │ -[13079](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000488 __imp_anon.941f0f04b36aa440174d89d326747b6f.33.llvm.16620058351426711825 │ │ │ │ │ -[13080](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c2358 free │ │ │ │ │ -[13081](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000720 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.99.llvm.13665133684747362110 │ │ │ │ │ -[13082](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000920 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.37.llvm.4036729494550109879 │ │ │ │ │ -[13083](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000f10 __data_end__ │ │ │ │ │ -[13084](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a288 WaitForMultipleObjects │ │ │ │ │ -[13085](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000948 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.42.llvm.4036729494550109879 │ │ │ │ │ -[13086](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001512c anon.7a6259c55b9abecd4a2eb0873fc8b779.43.llvm.10283439849247210698 │ │ │ │ │ -[13087](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000da8 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.18.llvm.17095335174290335670 │ │ │ │ │ -[13088](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003208 anon.edf9b0bdfd963b6a2ea99216811efd5e.110.llvm.65172163764165323 │ │ │ │ │ -[13089](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008b0 __imp_QueryPerformanceFrequency │ │ │ │ │ -[13090](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c31a0 ___CTOR_LIST__ │ │ │ │ │ -[13091](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a390 Module32FirstW │ │ │ │ │ -[13092](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002c0 __imp__ZN3std2io5stdio14OUTPUT_CAPTURE7__getit5__KEY17h4bf77338c012dfcbE.llvm.11685822864145163790 │ │ │ │ │ -[13093](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005b60 anon.2fc0b598515d6d45a6f7a748d37f9e68.43.llvm.9180192027238945235 │ │ │ │ │ -[13094](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006e8 __imp_CreateWaitableTimerExW │ │ │ │ │ -[13095](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a268 WriteFileEx │ │ │ │ │ -[13096](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000910 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.33.llvm.4036729494550109879 │ │ │ │ │ -[13097](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a648 accept │ │ │ │ │ -[13098](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006ee6 anon.5188eecf01c48ed8fcadadd01fcebeeb.46.llvm.10386673973210777259 │ │ │ │ │ -[13099](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007a0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.15.llvm.9180192027238945235 │ │ │ │ │ -[13100](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a440 GetFullPathNameW │ │ │ │ │ -[13101](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ba8 __imp_anon.f9f4f594184b6b9eb1b0ca5252c051c0.18.llvm.16633491867513938143 │ │ │ │ │ -[13102](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __minor_os_version__ │ │ │ │ │ -[13103](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000d8 __imp__ZN3std5panic14SHOULD_CAPTURE17h47fa1dca84a94988E.0.llvm.12196597439006139751 │ │ │ │ │ -[13104](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000958 __imp_TerminateProcess │ │ │ │ │ -[13105](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004f8 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.20.llvm.14048921605721191922 │ │ │ │ │ -[13106](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006898 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.58.llvm.4036729494550109879 │ │ │ │ │ -[13107](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000032e0 anon.edf9b0bdfd963b6a2ea99216811efd5e.118.llvm.65172163764165323 │ │ │ │ │ -[13108](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008f0 __imp_SetCurrentDirectoryW │ │ │ │ │ -[13109](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dd53 anon.07b55acb663eb35d742bae824872f75e.32.llvm.58757282566773765 │ │ │ │ │ -[13110](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000818 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.83.llvm.9180192027238945235 │ │ │ │ │ -[13111](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003948 anon.941f0f04b36aa440174d89d326747b6f.30.llvm.16620058351426711825 │ │ │ │ │ -[13112](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015ec8 anon.8d718ed12c404e6593cdb19a2e5276ea.5.llvm.819651363561423643 │ │ │ │ │ -[13113](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000368 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.0.llvm.65172163764165323 │ │ │ │ │ -[13114](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000d8 _ZN3std9panicking11panic_count18GLOBAL_PANIC_COUNT17h5b40b3f81b5486b3E │ │ │ │ │ -[13115](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000088 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.6.llvm.12196597439006139751 │ │ │ │ │ -[13116](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003740 anon.941f0f04b36aa440174d89d326747b6f.12.llvm.16620058351426711825 │ │ │ │ │ -[13117](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dccd anon.07b55acb663eb35d742bae824872f75e.25.llvm.58757282566773765 │ │ │ │ │ -[13118](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4a8 GetConsoleMode │ │ │ │ │ -[13119](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004b0 __imp_anon.941f0f04b36aa440174d89d326747b6f.57.llvm.16620058351426711825 │ │ │ │ │ -[13120](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000508 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.22.llvm.14048921605721191922 │ │ │ │ │ -[13121](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000780 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.11.llvm.9180192027238945235 │ │ │ │ │ -[13122](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c58 anon.c5e06b7d2fb27e4271afbca860883ce8.22.llvm.12196597439006139751 │ │ │ │ │ -[13123](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dbe9 anon.07b55acb663eb35d742bae824872f75e.9.llvm.58757282566773765 │ │ │ │ │ -[13124](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000300 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.6.llvm.9587153679006429619 │ │ │ │ │ -[13125](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003c20 anon.941f0f04b36aa440174d89d326747b6f.59.llvm.16620058351426711825 │ │ │ │ │ -[13126](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000688 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.14.llvm.13665133684747362110 │ │ │ │ │ -[13127](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006e0 __imp_CreateToolhelp32Snapshot │ │ │ │ │ -[13128](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000588 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.118.llvm.14048921605721191922 │ │ │ │ │ -[13129](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004738 anon.ce6f0c62864fa439afba1682d1475d3d.120.llvm.14048921605721191922 │ │ │ │ │ -[13130](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __dll__ │ │ │ │ │ -[13131](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3d0 GetWindowsDirectoryW │ │ │ │ │ -[13132](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c10 __imp_str.0.llvm.12123695082059135366 │ │ │ │ │ -[13133](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e70 __imp_anon.34ba7072d2fdbfb72b844525ea0f1e7b.0.llvm.3215435228619338225 │ │ │ │ │ -[13134](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000870 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.94.llvm.9180192027238945235 │ │ │ │ │ -[13135](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000620 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.0.llvm.13665133684747362110 │ │ │ │ │ -[13136](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ab0 __imp_WSARecv │ │ │ │ │ -[13137](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001db13 anon.07b55acb663eb35d742bae824872f75e.1.llvm.58757282566773765 │ │ │ │ │ -[13138](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006360 str.0.llvm.4036729494550109879 │ │ │ │ │ -[13139](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001e60 anon.577344e6c4a90a10ff600a929dedcba7.4.llvm.11685822864145163790 │ │ │ │ │ -[13140](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a38 __imp_realloc │ │ │ │ │ -[13141](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000029 _ZN3std2io5stdio19OUTPUT_CAPTURE_USED17he4f9ce513cba35dbE.0.llvm.11685822864145163790 │ │ │ │ │ -[13142](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003998 anon.941f0f04b36aa440174d89d326747b6f.33.llvm.16620058351426711825 │ │ │ │ │ -[13143](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000900 __imp_SetFileAttributesW │ │ │ │ │ -[13144](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000057fd anon.2fc0b598515d6d45a6f7a748d37f9e68.12.llvm.9180192027238945235 │ │ │ │ │ -[13145](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000052b8 anon.a43af9cc4981a42dd00b013f8f55f130.115.llvm.13665133684747362110 │ │ │ │ │ -[13146](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a340 RtlCaptureContext │ │ │ │ │ -[13147](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bb8 __imp_anon.3bd369ec61590d9272c591ac87029920.0.llvm.2123515186662715695 │ │ │ │ │ -[13148](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2180 _Unwind_Resume │ │ │ │ │ -[13149](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007e8 __imp_GetModuleHandleW │ │ │ │ │ -[13150](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009d0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.13.llvm.10386673973210777259 │ │ │ │ │ -[13151](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e38 __imp_anon.07b55acb663eb35d742bae824872f75e.28.llvm.58757282566773765 │ │ │ │ │ -[13152](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b08 __imp_anon.567cec0599d353b04e33d4229b5f9b30.9.llvm.2628756017061842597 │ │ │ │ │ -[13153](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005870 anon.2fc0b598515d6d45a6f7a748d37f9e68.16.llvm.9180192027238945235 │ │ │ │ │ -[13154](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000047c8 anon.a43af9cc4981a42dd00b013f8f55f130.2.llvm.13665133684747362110 │ │ │ │ │ -[13155](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013a78 anon.1cd6cbb5d23cd003f709872fa6a8a6dd.8.llvm.9517595369394268439 │ │ │ │ │ -[13156](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000338 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.17.llvm.9587153679006429619 │ │ │ │ │ -[13157](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010e98 anon.567cec0599d353b04e33d4229b5f9b30.10.llvm.2628756017061842597 │ │ │ │ │ -[13158](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000057d9 anon.2fc0b598515d6d45a6f7a748d37f9e68.11.llvm.9180192027238945235 │ │ │ │ │ -[13159](sec 7)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x0000000000000158 __rust_alloc_error_handler_should_panic │ │ │ │ │ -[13160](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022be0 .refptr.__native_dllmain_reason │ │ │ │ │ -[13161](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000888 anon.08c341bb7f186daefc16bdd18254cc9c.7.llvm.2852608270795916942 │ │ │ │ │ -[13162](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a658 WSASocketW │ │ │ │ │ -[13163](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001e30 anon.577344e6c4a90a10ff600a929dedcba7.0.llvm.11685822864145163790 │ │ │ │ │ -[13164](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000001d0 anon.7ce35b53eeafc768de935b4fef3da959.12.llvm.1024159395525823541 │ │ │ │ │ -[13165](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007f20 anon.75cd115d168aa5adc70873d7be22c67a.12.llvm.8768119154728042530 │ │ │ │ │ -[13166](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000250 __bss_end__ │ │ │ │ │ -[13167](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5e0 select │ │ │ │ │ -[13168](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009a8 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.2.llvm.10386673973210777259 │ │ │ │ │ -[13169](sec 11)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000008 _tls_end │ │ │ │ │ -[13170](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015318 anon.7a6259c55b9abecd4a2eb0873fc8b779.68.llvm.10283439849247210698 │ │ │ │ │ -[13171](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b68 __imp_anon.7ec0d7d1b51f482853d19890eaa43e99.13.llvm.4855701895496871646 │ │ │ │ │ -[13172](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015138 anon.7a6259c55b9abecd4a2eb0873fc8b779.49.llvm.10283439849247210698 │ │ │ │ │ -[13173](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000760 __imp_GetConsoleMode │ │ │ │ │ -[13174](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4f0 DuplicateHandle │ │ │ │ │ -[13175](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a478 GetEnvironmentVariableW │ │ │ │ │ -[13176](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005a10 anon.2fc0b598515d6d45a6f7a748d37f9e68.31.llvm.9180192027238945235 │ │ │ │ │ -[13177](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002f0 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.4.llvm.9587153679006429619 │ │ │ │ │ -[13178](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013506 anon.3bd369ec61590d9272c591ac87029920.6.llvm.2123515186662715695 │ │ │ │ │ -[13179](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000498 __imp_anon.941f0f04b36aa440174d89d326747b6f.43.llvm.16620058351426711825 │ │ │ │ │ -[13180](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a568 CopyFileExW │ │ │ │ │ -[13181](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000130 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.5.llvm.10021583357862909 │ │ │ │ │ -[13182](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000950 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.44.llvm.4036729494550109879 │ │ │ │ │ -[13183](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004844 anon.a43af9cc4981a42dd00b013f8f55f130.12.llvm.13665133684747362110 │ │ │ │ │ -[13184](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d88 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.14.llvm.17095335174290335670 │ │ │ │ │ -[13185](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002708 anon.2d4ed69d03b8b00b295e2865b118c80a.3.llvm.9587153679006429619 │ │ │ │ │ -[13186](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ce0 anon.c5e06b7d2fb27e4271afbca860883ce8.27.llvm.12196597439006139751 │ │ │ │ │ -[13187](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c3168 LeaveCriticalSection │ │ │ │ │ -[13188](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000738 __imp_FindNextFileW │ │ │ │ │ -[13189](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000c8 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.25.llvm.12196597439006139751 │ │ │ │ │ -[13190](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000868 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.93.llvm.9180192027238945235 │ │ │ │ │ -[13191](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007f8 __imp_GetProcAddress │ │ │ │ │ -[13192](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000de8 __imp_anon.07b55acb663eb35d742bae824872f75e.18.llvm.58757282566773765 │ │ │ │ │ -[13193](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ac8 __imp_WSAStartup │ │ │ │ │ -[13194](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002d0 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.0.llvm.9587153679006429619 │ │ │ │ │ -[13195](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004498 anon.ce6f0c62864fa439afba1682d1475d3d.82.llvm.14048921605721191922 │ │ │ │ │ -[13196](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000958 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.45.llvm.4036729494550109879 │ │ │ │ │ -[13197](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013845 anon.bb01d4b423a85a795a1692e8cd9c64e5.9.llvm.11285312269184381906 │ │ │ │ │ -[13198](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006b88 anon.5188eecf01c48ed8fcadadd01fcebeeb.13.llvm.10386673973210777259 │ │ │ │ │ -[13199](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000061f8 anon.2fc0b598515d6d45a6f7a748d37f9e68.91.llvm.9180192027238945235 │ │ │ │ │ -[13200](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000020 __xi_z │ │ │ │ │ -[13201](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ad8 __imp_anon.fc3e879c0d0583c039a7967db6c0c117.1.llvm.14670435032436802275 │ │ │ │ │ -[13202](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015116 anon.7a6259c55b9abecd4a2eb0873fc8b779.36.llvm.10283439849247210698 │ │ │ │ │ -[13203](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000af8 __imp_anon.567cec0599d353b04e33d4229b5f9b30.3.llvm.2628756017061842597 │ │ │ │ │ -[13204](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000200 __file_alignment__ │ │ │ │ │ -[13205](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3f0 GetSystemDirectoryW │ │ │ │ │ -[13206](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b80 __imp__Unwind_GetIPInfo │ │ │ │ │ -[13207](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000270 __imp_anon.577344e6c4a90a10ff600a929dedcba7.51.llvm.11685822864145163790 │ │ │ │ │ -[13208](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000060 anon.7ce35b53eeafc768de935b4fef3da959.2.llvm.1024159395525823541 │ │ │ │ │ -[13209](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000938 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.40.llvm.4036729494550109879 │ │ │ │ │ -[13210](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d68 anon.2611162d579b3e706d0c0f15accb8ea6.2.llvm.17987727548992354187 │ │ │ │ │ -[13211](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000194 __mingw_initltsdyn_force │ │ │ │ │ -[13212](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2f8 SetHandleInformation │ │ │ │ │ -[13213](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000012c8 anon.03a7b1eb39947173efb71e48c5b540f4.13.llvm.10021583357862909 │ │ │ │ │ -[13214](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4b8 FreeEnvironmentStringsW │ │ │ │ │ -[13215](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2368 memcpy │ │ │ │ │ -[13216](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d08 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.66.llvm.10283439849247210698 │ │ │ │ │ -[13217](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cc8 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.45.llvm.10283439849247210698 │ │ │ │ │ -[13218](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c48 __imp_anon.1cd6cbb5d23cd003f709872fa6a8a6dd.31.llvm.9517595369394268439 │ │ │ │ │ -[13219](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007f0 __imp_GetOverlappedResult │ │ │ │ │ -[13220](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000480 __imp_anon.941f0f04b36aa440174d89d326747b6f.32.llvm.16620058351426711825 │ │ │ │ │ -[13221](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002e0 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.2.llvm.9587153679006429619 │ │ │ │ │ -[13222](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c2348 _unlock │ │ │ │ │ -[13223](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000140 _ZN3std3sys3pal7windows3net11WSA_CLEANUP17he970e99e25d07381E.llvm.4036729494550109879 │ │ │ │ │ -[13224](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000510 __imp__ZN3std2rt7cleanup7CLEANUP17h07b9456e6b4bf964E.llvm.14048921605721191922 │ │ │ │ │ -[13225](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002e8 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.3.llvm.9587153679006429619 │ │ │ │ │ -[13226](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000037a0 anon.941f0f04b36aa440174d89d326747b6f.14.llvm.16620058351426711825 │ │ │ │ │ -[13227](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013952 anon.9de54bf691a285dd20d4e87e6b508fbd.8.llvm.12123695082059135366 │ │ │ │ │ -[13228](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005910 anon.2fc0b598515d6d45a6f7a748d37f9e68.21.llvm.9180192027238945235 │ │ │ │ │ -[13229](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dd50 anon.07b55acb663eb35d742bae824872f75e.31.llvm.58757282566773765 │ │ │ │ │ -[13230](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004340 anon.ce6f0c62864fa439afba1682d1475d3d.71.llvm.14048921605721191922 │ │ │ │ │ -[13231](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c30 __imp_anon.9de54bf691a285dd20d4e87e6b508fbd.9.llvm.12123695082059135366 │ │ │ │ │ -[13232](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcc9 anon.07b55acb663eb35d742bae824872f75e.23.llvm.58757282566773765 │ │ │ │ │ -[13233](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000670 __imp_AddVectoredExceptionHandler │ │ │ │ │ -[13234](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003e8 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.108.llvm.65172163764165323 │ │ │ │ │ -[13235](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003f0 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.109.llvm.65172163764165323 │ │ │ │ │ -[13236](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a380 MoveFileExW │ │ │ │ │ -[13237](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010338 anon.d13ef5d19e380ff1a25cb10df774bd92.2.llvm.13995198208019911955 │ │ │ │ │ -[13238](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2388 strlen │ │ │ │ │ -[13239](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000840 __imp_HeapAlloc │ │ │ │ │ -[13240](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000948 __imp_SleepEx │ │ │ │ │ -[13241](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5c0 shutdown │ │ │ │ │ -[13242](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000740 __imp_FlushFileBuffers │ │ │ │ │ -[13243](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000044b0 anon.ce6f0c62864fa439afba1682d1475d3d.83.llvm.14048921605721191922 │ │ │ │ │ -[13244](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006758 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.41.llvm.4036729494550109879 │ │ │ │ │ -[13245](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000dd0 anon.2611162d579b3e706d0c0f15accb8ea6.4.llvm.17987727548992354187 │ │ │ │ │ -[13246](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001e50 anon.577344e6c4a90a10ff600a929dedcba7.3.llvm.11685822864145163790 │ │ │ │ │ -[13247](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000160 _ZN10std_detect6detect5cache5CACHE17hf632556ed460aa26E │ │ │ │ │ -[13248](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015360 anon.7a6259c55b9abecd4a2eb0873fc8b779.71.llvm.10283439849247210698 │ │ │ │ │ -[13249](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004c88 anon.a43af9cc4981a42dd00b013f8f55f130.66.llvm.13665133684747362110 │ │ │ │ │ -[13250](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4f8 DeviceIoControl │ │ │ │ │ -[13251](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000019bc __lib64_libkernel32_a_iname │ │ │ │ │ -[13252](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000858 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.91.llvm.9180192027238945235 │ │ │ │ │ -[13253](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000069e0 anon.5188eecf01c48ed8fcadadd01fcebeeb.0.llvm.10386673973210777259 │ │ │ │ │ -[13254](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000003c _head_lib64_libmsvcrt_def_a │ │ │ │ │ -[13255](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000745f anon.5188eecf01c48ed8fcadadd01fcebeeb.102.llvm.10386673973210777259 │ │ │ │ │ -[13256](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dc20 anon.07b55acb663eb35d742bae824872f75e.12.llvm.58757282566773765 │ │ │ │ │ -[13257](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000060f1 anon.2fc0b598515d6d45a6f7a748d37f9e68.84.llvm.9180192027238945235 │ │ │ │ │ -[13258](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000229a0 __dyn_tls_init_callback │ │ │ │ │ -[13259](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000580 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.117.llvm.14048921605721191922 │ │ │ │ │ -[13260](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008f8 __imp_SetEnvironmentVariableW │ │ │ │ │ -[13261](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2c8 SwitchToThread │ │ │ │ │ -[13262](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001000 __size_of_stack_commit__ │ │ │ │ │ -[13263](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004720 anon.ce6f0c62864fa439afba1682d1475d3d.119.llvm.14048921605721191922 │ │ │ │ │ -[13264](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4e8 ExitProcess │ │ │ │ │ -[13265](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000160 __dll_characteristics__ │ │ │ │ │ -[13266](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022bf0 .refptr.__native_startup_lock │ │ │ │ │ -[13267](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000015b0 anon.03a7b1eb39947173efb71e48c5b540f4.51.llvm.10021583357862909 │ │ │ │ │ -[13268](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a30 __imp_memset │ │ │ │ │ -[13269](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e78 __imp_anon.34ba7072d2fdbfb72b844525ea0f1e7b.1.llvm.3215435228619338225 │ │ │ │ │ -[13270](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a78 anon.c5e06b7d2fb27e4271afbca860883ce8.6.llvm.12196597439006139751 │ │ │ │ │ -[13271](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000012e20 anon.7ec0d7d1b51f482853d19890eaa43e99.0.llvm.4855701895496871646 │ │ │ │ │ -[13272](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000017f8 ___tmp_rustcBv6EAf_bcryptprimitives_lib_iname │ │ │ │ │ +[12791](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000014 _head__tmp_rustcpdeyFw_bcryptprimitives_lib │ │ │ │ │ +[12792](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000017370 anon.df4f5fc91c1c1e84f2976758feaea474.20.llvm.17095335174290335670 │ │ │ │ │ +[12793](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009e8 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.16.llvm.10386673973210777259 │ │ │ │ │ +[12794](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013920 anon.9de54bf691a285dd20d4e87e6b508fbd.6.llvm.12123695082059135366 │ │ │ │ │ +[12795](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008c8 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.6.llvm.4036729494550109879 │ │ │ │ │ +[12796](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000128 _ZN3std6thread8ThreadId3new7COUNTER17hf61725333ea7cf69E.llvm.13665133684747362110 │ │ │ │ │ +[12797](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000152d8 anon.7a6259c55b9abecd4a2eb0873fc8b779.65.llvm.10283439849247210698 │ │ │ │ │ +[12798](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2188 _Unwind_RaiseException │ │ │ │ │ +[12799](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c2350 calloc │ │ │ │ │ +[12800](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000868 __imp_InitializeCriticalSection │ │ │ │ │ +[12801](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000730 __imp_FindFirstFileW │ │ │ │ │ +[12802](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000db8 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.20.llvm.17095335174290335670 │ │ │ │ │ +[12803](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003078 anon.edf9b0bdfd963b6a2ea99216811efd5e.81.llvm.65172163764165323 │ │ │ │ │ +[12804](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004778 anon.ce6f0c62864fa439afba1682d1475d3d.121.llvm.14048921605721191922 │ │ │ │ │ +[12805](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000010 ___crt_xi_start__ │ │ │ │ │ +[12806](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000090 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.7.llvm.12196597439006139751 │ │ │ │ │ +[12807](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015378 anon.7a6259c55b9abecd4a2eb0873fc8b779.72.llvm.10283439849247210698 │ │ │ │ │ +[12808](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007478 anon.5188eecf01c48ed8fcadadd01fcebeeb.104.llvm.10386673973210777259 │ │ │ │ │ +[12809](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000307c anon.edf9b0bdfd963b6a2ea99216811efd5e.82.llvm.65172163764165323 │ │ │ │ │ +[12810](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002b8 __imp__ZN3std4sync14reentrant_lock25current_thread_unique_ptr1X7__getit5__KEY17h077daefc5f25ce95E.llvm.11685822864145163790 │ │ │ │ │ +[12811](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2170 _Unwind_SetIP │ │ │ │ │ +[12812](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a58 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.106.llvm.10386673973210777259 │ │ │ │ │ +[12813](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000840 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.88.llvm.9180192027238945235 │ │ │ │ │ +[12814](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006648 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.31.llvm.4036729494550109879 │ │ │ │ │ +[12815](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b40 __imp_anon.c4d194f4cabed4ef9246cda43331cffc.3.llvm.6008810897942320446 │ │ │ │ │ +[12816](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002a0 __imp_anon.577344e6c4a90a10ff600a929dedcba7.84.llvm.11685822864145163790 │ │ │ │ │ +[12817](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcca anon.07b55acb663eb35d742bae824872f75e.24.llvm.58757282566773765 │ │ │ │ │ +[12818](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004c0 __imp_anon.941f0f04b36aa440174d89d326747b6f.59.llvm.16620058351426711825 │ │ │ │ │ +[12819](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000011c8 anon.03a7b1eb39947173efb71e48c5b540f4.5.llvm.10021583357862909 │ │ │ │ │ +[12820](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e4f anon.ce6f0c62864fa439afba1682d1475d3d.19.llvm.14048921605721191922 │ │ │ │ │ +[12821](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000570 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.115.llvm.14048921605721191922 │ │ │ │ │ +[12822](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000af8 anon.c5e06b7d2fb27e4271afbca860883ce8.10.llvm.12196597439006139751 │ │ │ │ │ +[12823](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000748 __imp__ZN3std4sync4mpmc5waker17current_thread_id5DUMMY7__getit5__KEY17h8fc5a22a2d7694d4E.llvm.13665133684747362110 │ │ │ │ │ +[12824](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008d8 __imp_str.0.llvm.4036729494550109879 │ │ │ │ │ +[12825](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015125 anon.7a6259c55b9abecd4a2eb0873fc8b779.39.llvm.10283439849247210698 │ │ │ │ │ +[12826](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a608 getsockopt │ │ │ │ │ +[12827](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006790 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.42.llvm.4036729494550109879 │ │ │ │ │ +[12828](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000668 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.10.llvm.13665133684747362110 │ │ │ │ │ +[12829](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006392 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.9.llvm.4036729494550109879 │ │ │ │ │ +[12830](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000005 __major_subsystem_version__ │ │ │ │ │ +[12831](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006710 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.38.llvm.4036729494550109879 │ │ │ │ │ +[12832](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000820 __imp_GetSystemInfo │ │ │ │ │ +[12833](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002d8 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.1.llvm.9587153679006429619 │ │ │ │ │ +[12834](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000012930 anon.c4d194f4cabed4ef9246cda43331cffc.2.llvm.6008810897942320446 │ │ │ │ │ +[12835](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006b0 __imp_CreateFileW │ │ │ │ │ +[12836](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2b0 TlsFree │ │ │ │ │ +[12837](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a368 QueryPerformanceFrequency │ │ │ │ │ +[12838](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006f50 anon.5188eecf01c48ed8fcadadd01fcebeeb.49.llvm.10386673973210777259 │ │ │ │ │ +[12839](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d20 anon.2611162d579b3e706d0c0f15accb8ea6.0.llvm.17987727548992354187 │ │ │ │ │ +[12840](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010358 anon.d13ef5d19e380ff1a25cb10df774bd92.3.llvm.13995198208019911955 │ │ │ │ │ +[12841](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c10 .refptr.__rust_alloc_error_handler_should_panic │ │ │ │ │ +[12842](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006a8 __imp_CreateFileMappingA │ │ │ │ │ +[12843](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000db0 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.19.llvm.17095335174290335670 │ │ │ │ │ +[12844](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000628 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.2.llvm.13665133684747362110 │ │ │ │ │ +[12845](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000838 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.87.llvm.9180192027238945235 │ │ │ │ │ +[12846](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000140 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.8.llvm.10021583357862909 │ │ │ │ │ +[12847](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000240 __imp__ZN3std2io5stdio6STDOUT17h54404b6e0dbb130cE.llvm.11685822864145163790 │ │ │ │ │ +[12848](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003c8 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.82.llvm.65172163764165323 │ │ │ │ │ +[12849](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000152c8 anon.7a6259c55b9abecd4a2eb0873fc8b779.64.llvm.10283439849247210698 │ │ │ │ │ +[12850](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2e8 SetThreadStackGuarantee │ │ │ │ │ +[12851](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006e0 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.53.llvm.13665133684747362110 │ │ │ │ │ +[12852](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000af0 __imp_freeaddrinfo │ │ │ │ │ +[12853](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009b0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.3.llvm.10386673973210777259 │ │ │ │ │ +[12854](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a348 RemoveDirectoryW │ │ │ │ │ +[12855](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a468 GetFileAttributesW │ │ │ │ │ +[12856](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3a0 InitializeProcThreadAttributeList │ │ │ │ │ +[12857](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d70 __imp__ZN4core7unicode12unicode_data15grapheme_extend17SHORT_OFFSET_RUNS17hcc65fb30137b448cE.llvm.819651363561423643 │ │ │ │ │ +[12858](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002260 anon.577344e6c4a90a10ff600a929dedcba7.52.llvm.11685822864145163790 │ │ │ │ │ +[12859](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000778 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.10.llvm.9180192027238945235 │ │ │ │ │ +[12860](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006b78 anon.5188eecf01c48ed8fcadadd01fcebeeb.12.llvm.10386673973210777259 │ │ │ │ │ +[12861](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c50 __imp__ZN4core3num7flt2dec8strategy5grisu12CACHED_POW1017hc29b3bf8237d228dE │ │ │ │ │ +[12862](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008d0 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.7.llvm.4036729494550109879 │ │ │ │ │ +[12863](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000120 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.2.llvm.10021583357862909 │ │ │ │ │ +[12864](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d50 anon.2611162d579b3e706d0c0f15accb8ea6.1.llvm.17987727548992354187 │ │ │ │ │ +[12865](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000768 __imp_anon.71b4c3b3c7c90ed67c6b8e618b4d496a.6.llvm.14138378158770856212 │ │ │ │ │ +[12866](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a378 MultiByteToWideChar │ │ │ │ │ +[12867](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000728 __imp__ZN3std6thread8ThreadId3new7COUNTER17hf61725333ea7cf69E.llvm.13665133684747362110 │ │ │ │ │ +[12868](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000050 ___crt_xt_end__ │ │ │ │ │ +[12869](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b00 __imp_getpeername │ │ │ │ │ +[12870](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b70 __imp__Unwind_DeleteException │ │ │ │ │ +[12871](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000298 __imp_anon.577344e6c4a90a10ff600a929dedcba7.83.llvm.11685822864145163790 │ │ │ │ │ +[12872](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000001a8 _ZN3std10sys_common11thread_info11THREAD_INFO7__getit5__KEY17ha20a47e83639d552E.llvm.11685822864145163790 │ │ │ │ │ +[12873](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013c18 anon.1cd6cbb5d23cd003f709872fa6a8a6dd.31.llvm.9517595369394268439 │ │ │ │ │ +[12874](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003e14 anon.ce6f0c62864fa439afba1682d1475d3d.18.llvm.14048921605721191922 │ │ │ │ │ +[12875](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3b0 InitOnceBeginInitialize │ │ │ │ │ +[12876](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000017200 anon.df4f5fc91c1c1e84f2976758feaea474.15.llvm.17095335174290335670 │ │ │ │ │ +[12877](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000047a8 anon.a43af9cc4981a42dd00b013f8f55f130.0.llvm.13665133684747362110 │ │ │ │ │ +[12878](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a650 WSAStartup │ │ │ │ │ +[12879](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ae0 anon.c5e06b7d2fb27e4271afbca860883ce8.9.llvm.12196597439006139751 │ │ │ │ │ +[12880](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000050 ___crt_xt_start__ │ │ │ │ │ +[12881](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000165d8 anon.8d718ed12c404e6593cdb19a2e5276ea.23.llvm.819651363561423643 │ │ │ │ │ +[12882](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022ec0 ___RUNTIME_PSEUDO_RELOC_LIST__ │ │ │ │ │ +[12883](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2198 _Unwind_GetRegionStart │ │ │ │ │ +[12884](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000828 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.85.llvm.9180192027238945235 │ │ │ │ │ +[12885](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000067e8 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.45.llvm.4036729494550109879 │ │ │ │ │ +[12886](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000016684 _ZN4core7unicode12unicode_data15grapheme_extend17SHORT_OFFSET_RUNS17hcc65fb30137b448cE.llvm.819651363561423643 │ │ │ │ │ +[12887](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a470 GetExitCodeProcess │ │ │ │ │ +[12888](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002740 anon.2d4ed69d03b8b00b295e2865b118c80a.4.llvm.9587153679006429619 │ │ │ │ │ +[12889](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000026d0 anon.2d4ed69d03b8b00b295e2865b118c80a.0.llvm.9587153679006429619 │ │ │ │ │ +[12890](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000152f8 anon.7a6259c55b9abecd4a2eb0873fc8b779.66.llvm.10283439849247210698 │ │ │ │ │ +[12891](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000708 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.65.llvm.13665133684747362110 │ │ │ │ │ +[12892](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000698 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.16.llvm.13665133684747362110 │ │ │ │ │ +[12893](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ac0 __imp_WSASocketW │ │ │ │ │ +[12894](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000078 _head_lib64_libws2_32_a │ │ │ │ │ +[12895](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a308 SetFilePointerEx │ │ │ │ │ +[12896](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015928 anon.d59256ba366f0704cef723753273bccf.6.llvm.4660425447921612699 │ │ │ │ │ +[12897](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __major_image_version__ │ │ │ │ │ +[12898](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001000 __section_alignment__ │ │ │ │ │ +[12899](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000068 __imp_anon.08c341bb7f186daefc16bdd18254cc9c.7.llvm.2852608270795916942 │ │ │ │ │ +[12900](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3e8 GetSystemInfo │ │ │ │ │ +[12901](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007438 anon.5188eecf01c48ed8fcadadd01fcebeeb.101.llvm.10386673973210777259 │ │ │ │ │ +[12902](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010ed0 anon.567cec0599d353b04e33d4229b5f9b30.12.llvm.2628756017061842597 │ │ │ │ │ +[12903](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000660 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.9.llvm.13665133684747362110 │ │ │ │ │ +[12904](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000908 __imp_SetFileInformationByHandle │ │ │ │ │ +[12905](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004468 anon.ce6f0c62864fa439afba1682d1475d3d.81.llvm.14048921605721191922 │ │ │ │ │ +[12906](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003750 anon.941f0f04b36aa440174d89d326747b6f.13.llvm.16620058351426711825 │ │ │ │ │ +[12907](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000858 anon.08c341bb7f186daefc16bdd18254cc9c.5.llvm.2852608270795916942 │ │ │ │ │ +[12908](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000a8 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.10.llvm.12196597439006139751 │ │ │ │ │ +[12909](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d90 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.15.llvm.17095335174290335670 │ │ │ │ │ +[12910](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000100 __imp_anon.2611162d579b3e706d0c0f15accb8ea6.1.llvm.17987727548992354187 │ │ │ │ │ +[12911](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006210 anon.2fc0b598515d6d45a6f7a748d37f9e68.92.llvm.9180192027238945235 │ │ │ │ │ +[12912](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000250 __imp_anon.577344e6c4a90a10ff600a929dedcba7.36.llvm.11685822864145163790 │ │ │ │ │ +[12913](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008f0 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.10.llvm.4036729494550109879 │ │ │ │ │ +[12914](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000048bb anon.a43af9cc4981a42dd00b013f8f55f130.21.llvm.13665133684747362110 │ │ │ │ │ +[12915](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a510 CreateWaitableTimerExW │ │ │ │ │ +[12916](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002868 anon.2d4ed69d03b8b00b295e2865b118c80a.14.llvm.9587153679006429619 │ │ │ │ │ +[12917](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000500 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.21.llvm.14048921605721191922 │ │ │ │ │ +[12918](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000678 __imp_CancelIo │ │ │ │ │ +[12919](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008c0 __imp_ReadFile │ │ │ │ │ +[12920](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000260 __imp__ZN3std2io5stdio6stderr8INSTANCE17h050c730875ffdbc8E │ │ │ │ │ +[12921](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ac0 __imp_anon.75cd115d168aa5adc70873d7be22c67a.11.llvm.8768119154728042530 │ │ │ │ │ +[12922](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000520 __imp__ZN3std10sys_common9backtrace4lock4LOCK17h96194423af38a9eeE.llvm.14048921605721191922 │ │ │ │ │ +[12923](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000540 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.79.llvm.14048921605721191922 │ │ │ │ │ +[12924](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a458 GetFileInformationByHandleEx │ │ │ │ │ +[12925](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022c00 .refptr.__native_startup_state │ │ │ │ │ +[12926](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4a0 GetCurrentDirectoryW │ │ │ │ │ +[12927](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000930 __imp_SetThreadStackGuarantee │ │ │ │ │ +[12928](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dc80 anon.07b55acb663eb35d742bae824872f75e.19.llvm.58757282566773765 │ │ │ │ │ +[12929](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2190 _Unwind_GetTextRelBase │ │ │ │ │ +[12930](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000081d8 anon.fc3e879c0d0583c039a7967db6c0c117.1.llvm.14670435032436802275 │ │ │ │ │ +[12931](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001654b anon.8d718ed12c404e6593cdb19a2e5276ea.18.llvm.819651363561423643 │ │ │ │ │ +[12932](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000028 ___crt_xl_start__ │ │ │ │ │ +[12933](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005548 anon.71b4c3b3c7c90ed67c6b8e618b4d496a.0.llvm.14138378158770856212 │ │ │ │ │ +[12934](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c31b8 __DTOR_LIST__ │ │ │ │ │ +[12935](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004b20 anon.a43af9cc4981a42dd00b013f8f55f130.54.llvm.13665133684747362110 │ │ │ │ │ +[12936](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008d8 __imp_RtlCaptureContext │ │ │ │ │ +[12937](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000f0 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.29.llvm.12196597439006139751 │ │ │ │ │ +[12938](sec 4)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 rust_metadata_std_9f917a5e7a74ff1 │ │ │ │ │ +[12939](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006f0 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.57.llvm.13665133684747362110 │ │ │ │ │ +[12940](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a450 GetFileType │ │ │ │ │ +[12941](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a408 GetProcessHeap │ │ │ │ │ +[12942](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a40 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.102.llvm.10386673973210777259 │ │ │ │ │ +[12943](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000be8 __imp_anon.bb01d4b423a85a795a1692e8cd9c64e5.2.llvm.11285312269184381906 │ │ │ │ │ +[12944](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000062c0 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.1.llvm.4036729494550109879 │ │ │ │ │ +[12945](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a18 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.51.llvm.10386673973210777259 │ │ │ │ │ +[12946](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000960 __imp__ZN3std3sys3pal7windows5alloc4HEAP17h34e549f5a2364763E │ │ │ │ │ +[12947](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008c8 __imp_ReadFileEx │ │ │ │ │ +[12948](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000400 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.111.llvm.65172163764165323 │ │ │ │ │ +[12949](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000047e0 anon.a43af9cc4981a42dd00b013f8f55f130.4.llvm.13665133684747362110 │ │ │ │ │ +[12950](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004a0 __imp_anon.941f0f04b36aa440174d89d326747b6f.53.llvm.16620058351426711825 │ │ │ │ │ +[12951](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000590 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.119.llvm.14048921605721191922 │ │ │ │ │ +[12952](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dc68 anon.07b55acb663eb35d742bae824872f75e.18.llvm.58757282566773765 │ │ │ │ │ +[12953](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000017f8 ___tmp_rustcpdeyFw_bcryptprimitives_lib_iname │ │ │ │ │ +[12954](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __bss_start__ │ │ │ │ │ +[12955](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c3160 VirtualProtect │ │ │ │ │ +[12956](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e30 __imp_anon.07b55acb663eb35d742bae824872f75e.27.llvm.58757282566773765 │ │ │ │ │ +[12957](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000134c8 anon.3bd369ec61590d9272c591ac87029920.1.llvm.2123515186662715695 │ │ │ │ │ +[12958](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000071d8 anon.5188eecf01c48ed8fcadadd01fcebeeb.71.llvm.10386673973210777259 │ │ │ │ │ +[12959](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000518 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.49.llvm.14048921605721191922 │ │ │ │ │ +[12960](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000550 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.81.llvm.14048921605721191922 │ │ │ │ │ +[12961](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003d0 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.83.llvm.65172163764165323 │ │ │ │ │ +[12962](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5c8 setsockopt │ │ │ │ │ +[12963](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006740 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.40.llvm.4036729494550109879 │ │ │ │ │ +[12964](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007e0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.40.llvm.9180192027238945235 │ │ │ │ │ +[12965](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000650 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.7.llvm.13665133684747362110 │ │ │ │ │ +[12966](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d40 __imp_anon.d59256ba366f0704cef723753273bccf.6.llvm.4660425447921612699 │ │ │ │ │ +[12967](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007a50 anon.e2378e14a3ab6920970de912c40858fb.1.llvm.12155384279649763508 │ │ │ │ │ +[12968](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004886 anon.a43af9cc4981a42dd00b013f8f55f130.17.llvm.13665133684747362110 │ │ │ │ │ +[12969](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ce0 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.48.llvm.10283439849247210698 │ │ │ │ │ +[12970](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a88 __imp_GetUserProfileDirectoryW │ │ │ │ │ +[12971](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022bb0 .refptr.__dyn_tls_init_callback │ │ │ │ │ +[12972](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000690 __imp_CopyFileExW │ │ │ │ │ +[12973](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000700 __imp_DeleteProcThreadAttributeList │ │ │ │ │ +[12974](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002c8 __imp__ZN3std9panicking11panic_count18GLOBAL_PANIC_COUNT17h5b40b3f81b5486b3E │ │ │ │ │ +[12975](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000dc8 __imp_anon.07b55acb663eb35d742bae824872f75e.1.llvm.58757282566773765 │ │ │ │ │ +[12976](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009c0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.11.llvm.10386673973210777259 │ │ │ │ │ +[12977](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000581c anon.2fc0b598515d6d45a6f7a748d37f9e68.13.llvm.9180192027238945235 │ │ │ │ │ +[12978](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000070 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.0.llvm.12196597439006139751 │ │ │ │ │ +[12979](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000027c0 anon.2d4ed69d03b8b00b295e2865b118c80a.7.llvm.9587153679006429619 │ │ │ │ │ +[12980](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __minor_image_version__ │ │ │ │ │ +[12981](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000838 __imp_GetWindowsDirectoryW │ │ │ │ │ +[12982](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dd08 anon.07b55acb663eb35d742bae824872f75e.29.llvm.58757282566773765 │ │ │ │ │ +[12983](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007d0 __imp_GetLastError │ │ │ │ │ +[12984](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002e48 anon.edf9b0bdfd963b6a2ea99216811efd5e.55.llvm.65172163764165323 │ │ │ │ │ +[12985](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000071b0 anon.5188eecf01c48ed8fcadadd01fcebeeb.70.llvm.10386673973210777259 │ │ │ │ │ +[12986](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000010 __imp_anon.7ce35b53eeafc768de935b4fef3da959.2.llvm.1024159395525823541 │ │ │ │ │ +[12987](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000880 __imp_MapViewOfFile │ │ │ │ │ +[12988](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000168 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.51.llvm.10021583357862909 │ │ │ │ │ +[12989](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009d0 anon.c5e06b7d2fb27e4271afbca860883ce8.0.llvm.12196597439006139751 │ │ │ │ │ +[12990](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000880 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.97.llvm.9180192027238945235 │ │ │ │ │ +[12991](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007b8 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.18.llvm.9180192027238945235 │ │ │ │ │ +[12992](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000050 ___crt_xp_end__ │ │ │ │ │ +[12993](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ae8 __imp_anon.d13ef5d19e380ff1a25cb10df774bd92.3.llvm.13995198208019911955 │ │ │ │ │ +[12994](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000048cd anon.a43af9cc4981a42dd00b013f8f55f130.22.llvm.13665133684747362110 │ │ │ │ │ +[12995](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000578 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.116.llvm.14048921605721191922 │ │ │ │ │ +[12996](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000018 __imp_anon.7ce35b53eeafc768de935b4fef3da959.3.llvm.1024159395525823541 │ │ │ │ │ +[12997](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c58 __imp__ZN4core3fmt2rt12USIZE_MARKER17hd232ed6d40ac3ff2E │ │ │ │ │ +[12998](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000020 __imp_anon.7ce35b53eeafc768de935b4fef3da959.4.llvm.1024159395525823541 │ │ │ │ │ +[12999](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000990 __imp_VirtualProtect │ │ │ │ │ +[13000](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006d8 __imp_CreateThread │ │ │ │ │ +[13001](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000388 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.53.llvm.65172163764165323 │ │ │ │ │ +[13002](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b00 __imp_anon.567cec0599d353b04e33d4229b5f9b30.4.llvm.2628756017061842597 │ │ │ │ │ +[13003](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a70 __imp_NtWriteFile │ │ │ │ │ +[13004](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000020ad0 anon.34ba7072d2fdbfb72b844525ea0f1e7b.0.llvm.3215435228619338225 │ │ │ │ │ +[13005](sec 11)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 ___tls_start__ │ │ │ │ │ +[13006](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ca8 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.41.llvm.10283439849247210698 │ │ │ │ │ +[13007](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000038 __imp_anon.08c341bb7f186daefc16bdd18254cc9c.0.llvm.2852608270795916942 │ │ │ │ │ +[13008](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a460 GetFileInformationByHandle │ │ │ │ │ +[13009](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a618 getpeername │ │ │ │ │ +[13010](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001a2c __lib64_libntdll_a_iname │ │ │ │ │ +[13011](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002fe8 anon.edf9b0bdfd963b6a2ea99216811efd5e.76.llvm.65172163764165323 │ │ │ │ │ +[13012](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000f0 _ZN3std10sys_common9backtrace4lock4LOCK17h96194423af38a9eeE.llvm.14048921605721191922 │ │ │ │ │ +[13013](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000800 __imp_GetProcessHeap │ │ │ │ │ +[13014](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000074c8 anon.5188eecf01c48ed8fcadadd01fcebeeb.107.llvm.10386673973210777259 │ │ │ │ │ +[13015](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007b0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.17.llvm.9180192027238945235 │ │ │ │ │ +[13016](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cf0 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.50.llvm.10283439849247210698 │ │ │ │ │ +[13017](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000278 __imp_anon.577344e6c4a90a10ff600a929dedcba7.52.llvm.11685822864145163790 │ │ │ │ │ +[13018](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a48 __imp_strncmp │ │ │ │ │ +[13019](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001eb0 anon.577344e6c4a90a10ff600a929dedcba7.6.llvm.11685822864145163790 │ │ │ │ │ +[13020](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000470 __imp_anon.941f0f04b36aa440174d89d326747b6f.30.llvm.16620058351426711825 │ │ │ │ │ +[13021](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000978 __imp_TlsSetValue │ │ │ │ │ +[13022](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000790 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.13.llvm.9180192027238945235 │ │ │ │ │ +[13023](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009d8 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.14.llvm.10386673973210777259 │ │ │ │ │ +[13024](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000047d5 anon.a43af9cc4981a42dd00b013f8f55f130.3.llvm.13665133684747362110 │ │ │ │ │ +[13025](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022b90 .refptr.__RUNTIME_PSEUDO_RELOC_LIST_END__ │ │ │ │ │ +[13026](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000019c _tls_index │ │ │ │ │ +[13027](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000650 __imp_WakeByAddressSingle │ │ │ │ │ +[13028](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cb0 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.42.llvm.10283439849247210698 │ │ │ │ │ +[13029](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007f8 anon.08c341bb7f186daefc16bdd18254cc9c.3.llvm.2852608270795916942 │ │ │ │ │ +[13030](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b38 __imp_anon.c4d194f4cabed4ef9246cda43331cffc.2.llvm.6008810897942320446 │ │ │ │ │ +[13031](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009a0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.1.llvm.10386673973210777259 │ │ │ │ │ +[13032](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000486b anon.a43af9cc4981a42dd00b013f8f55f130.15.llvm.13665133684747362110 │ │ │ │ │ +[13033](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007d0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.21.llvm.9180192027238945235 │ │ │ │ │ +[13034](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000928 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.38.llvm.4036729494550109879 │ │ │ │ │ +[13035](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007e0 __imp_GetModuleHandleA │ │ │ │ │ +[13036](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006f28 anon.5188eecf01c48ed8fcadadd01fcebeeb.48.llvm.10386673973210777259 │ │ │ │ │ +[13037](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a28 __imp_memmove │ │ │ │ │ +[13038](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000410 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.117.llvm.65172163764165323 │ │ │ │ │ +[13039](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003c0 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.81.llvm.65172163764165323 │ │ │ │ │ +[13040](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e10 __imp_anon.07b55acb663eb35d742bae824872f75e.23.llvm.58757282566773765 │ │ │ │ │ +[13041](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3f8 GetStdHandle │ │ │ │ │ +[13042](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000640 __IAT_start__ │ │ │ │ │ +[13043](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b28 __imp__ZN10std_detect6detect5cache5CACHE17hf632556ed460aa26E │ │ │ │ │ +[13044](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000708 __imp_DeviceIoControl │ │ │ │ │ +[13045](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000010 ___crt_xc_end__ │ │ │ │ │ +[13046](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c31a0 __CTOR_LIST__ │ │ │ │ │ +[13047](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004835 anon.a43af9cc4981a42dd00b013f8f55f130.11.llvm.13665133684747362110 │ │ │ │ │ +[13048](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000080 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.2.llvm.12196597439006139751 │ │ │ │ │ +[13049](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001228 anon.03a7b1eb39947173efb71e48c5b540f4.8.llvm.10021583357862909 │ │ │ │ │ +[13050](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d28 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.70.llvm.10283439849247210698 │ │ │ │ │ +[13051](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2a0 TlsSetValue │ │ │ │ │ +[13052](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000798 __imp_GetExitCodeProcess │ │ │ │ │ +[13053](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009d0 __imp___iob_func │ │ │ │ │ +[13054](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000848 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.89.llvm.9180192027238945235 │ │ │ │ │ +[13055](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015158 anon.7a6259c55b9abecd4a2eb0873fc8b779.50.llvm.10283439849247210698 │ │ │ │ │ +[13056](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __data_start__ │ │ │ │ │ +[13057](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006728 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.39.llvm.4036729494550109879 │ │ │ │ │ +[13058](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002600 anon.577344e6c4a90a10ff600a929dedcba7.84.llvm.11685822864145163790 │ │ │ │ │ +[13059](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000830 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.86.llvm.9180192027238945235 │ │ │ │ │ +[13060](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000005e0 _ZN3std4sync4mpmc5waker17current_thread_id5DUMMY7__getit5__KEY17h8fc5a22a2d7694d4E.llvm.13665133684747362110 │ │ │ │ │ +[13061](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3a8 InitOnceComplete │ │ │ │ │ +[13062](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5b0 GetUserProfileDirectoryW │ │ │ │ │ +[13063](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006f10 anon.5188eecf01c48ed8fcadadd01fcebeeb.47.llvm.10386673973210777259 │ │ │ │ │ +[13064](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c2338 _initterm │ │ │ │ │ +[13065](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a10 __imp_fwrite │ │ │ │ │ +[13066](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5d0 sendto │ │ │ │ │ +[13067](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004ba0 anon.a43af9cc4981a42dd00b013f8f55f130.57.llvm.13665133684747362110 │ │ │ │ │ +[13068](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007b0 anon.08c341bb7f186daefc16bdd18254cc9c.0.llvm.2852608270795916942 │ │ │ │ │ +[13069](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a50 __imp_vfprintf │ │ │ │ │ +[13070](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2150 WakeByAddressSingle │ │ │ │ │ +[13071](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3b8 HeapReAlloc │ │ │ │ │ +[13072](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bd8 __imp_anon.3bd369ec61590d9272c591ac87029920.6.llvm.2123515186662715695 │ │ │ │ │ +[13073](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000008c _head_libgcc_s_seh_1_dll │ │ │ │ │ +[13074](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000268 __imp_anon.577344e6c4a90a10ff600a929dedcba7.48.llvm.11685822864145163790 │ │ │ │ │ +[13075](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000558 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.82.llvm.14048921605721191922 │ │ │ │ │ +[13076](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000aa8 __imp_WSAGetLastError │ │ │ │ │ +[13077](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c08 __imp_anon.9de54bf691a285dd20d4e87e6b508fbd.5.llvm.12123695082059135366 │ │ │ │ │ +[13078](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006b0 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.19.llvm.13665133684747362110 │ │ │ │ │ +[13079](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ea0 __imp_anon.d5fd6146a7cb5ea87f639cab18b2a05b.46.llvm.3779847476987057767 │ │ │ │ │ +[13080](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000488 __imp_anon.941f0f04b36aa440174d89d326747b6f.33.llvm.16620058351426711825 │ │ │ │ │ +[13081](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c2358 free │ │ │ │ │ +[13082](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000720 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.99.llvm.13665133684747362110 │ │ │ │ │ +[13083](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000920 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.37.llvm.4036729494550109879 │ │ │ │ │ +[13084](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000f10 __data_end__ │ │ │ │ │ +[13085](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a288 WaitForMultipleObjects │ │ │ │ │ +[13086](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000948 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.42.llvm.4036729494550109879 │ │ │ │ │ +[13087](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001512c anon.7a6259c55b9abecd4a2eb0873fc8b779.43.llvm.10283439849247210698 │ │ │ │ │ +[13088](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000da8 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.18.llvm.17095335174290335670 │ │ │ │ │ +[13089](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003208 anon.edf9b0bdfd963b6a2ea99216811efd5e.110.llvm.65172163764165323 │ │ │ │ │ +[13090](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008b0 __imp_QueryPerformanceFrequency │ │ │ │ │ +[13091](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c31a0 ___CTOR_LIST__ │ │ │ │ │ +[13092](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a390 Module32FirstW │ │ │ │ │ +[13093](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002c0 __imp__ZN3std2io5stdio14OUTPUT_CAPTURE7__getit5__KEY17h4bf77338c012dfcbE.llvm.11685822864145163790 │ │ │ │ │ +[13094](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005b60 anon.2fc0b598515d6d45a6f7a748d37f9e68.43.llvm.9180192027238945235 │ │ │ │ │ +[13095](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006e8 __imp_CreateWaitableTimerExW │ │ │ │ │ +[13096](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a268 WriteFileEx │ │ │ │ │ +[13097](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000910 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.33.llvm.4036729494550109879 │ │ │ │ │ +[13098](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a648 accept │ │ │ │ │ +[13099](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006ee6 anon.5188eecf01c48ed8fcadadd01fcebeeb.46.llvm.10386673973210777259 │ │ │ │ │ +[13100](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007a0 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.15.llvm.9180192027238945235 │ │ │ │ │ +[13101](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a440 GetFullPathNameW │ │ │ │ │ +[13102](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ba8 __imp_anon.f9f4f594184b6b9eb1b0ca5252c051c0.18.llvm.16633491867513938143 │ │ │ │ │ +[13103](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __minor_os_version__ │ │ │ │ │ +[13104](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000d8 __imp__ZN3std5panic14SHOULD_CAPTURE17h47fa1dca84a94988E.0.llvm.12196597439006139751 │ │ │ │ │ +[13105](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000958 __imp_TerminateProcess │ │ │ │ │ +[13106](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004f8 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.20.llvm.14048921605721191922 │ │ │ │ │ +[13107](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006898 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.58.llvm.4036729494550109879 │ │ │ │ │ +[13108](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000032e0 anon.edf9b0bdfd963b6a2ea99216811efd5e.118.llvm.65172163764165323 │ │ │ │ │ +[13109](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008f0 __imp_SetCurrentDirectoryW │ │ │ │ │ +[13110](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dd53 anon.07b55acb663eb35d742bae824872f75e.32.llvm.58757282566773765 │ │ │ │ │ +[13111](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000818 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.83.llvm.9180192027238945235 │ │ │ │ │ +[13112](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003948 anon.941f0f04b36aa440174d89d326747b6f.30.llvm.16620058351426711825 │ │ │ │ │ +[13113](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015ec8 anon.8d718ed12c404e6593cdb19a2e5276ea.5.llvm.819651363561423643 │ │ │ │ │ +[13114](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000368 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.0.llvm.65172163764165323 │ │ │ │ │ +[13115](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000d8 _ZN3std9panicking11panic_count18GLOBAL_PANIC_COUNT17h5b40b3f81b5486b3E │ │ │ │ │ +[13116](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000088 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.6.llvm.12196597439006139751 │ │ │ │ │ +[13117](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003740 anon.941f0f04b36aa440174d89d326747b6f.12.llvm.16620058351426711825 │ │ │ │ │ +[13118](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dccd anon.07b55acb663eb35d742bae824872f75e.25.llvm.58757282566773765 │ │ │ │ │ +[13119](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4a8 GetConsoleMode │ │ │ │ │ +[13120](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000004b0 __imp_anon.941f0f04b36aa440174d89d326747b6f.57.llvm.16620058351426711825 │ │ │ │ │ +[13121](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000508 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.22.llvm.14048921605721191922 │ │ │ │ │ +[13122](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000780 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.11.llvm.9180192027238945235 │ │ │ │ │ +[13123](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c58 anon.c5e06b7d2fb27e4271afbca860883ce8.22.llvm.12196597439006139751 │ │ │ │ │ +[13124](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dbe9 anon.07b55acb663eb35d742bae824872f75e.9.llvm.58757282566773765 │ │ │ │ │ +[13125](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000300 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.6.llvm.9587153679006429619 │ │ │ │ │ +[13126](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003c20 anon.941f0f04b36aa440174d89d326747b6f.59.llvm.16620058351426711825 │ │ │ │ │ +[13127](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000688 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.14.llvm.13665133684747362110 │ │ │ │ │ +[13128](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000006e0 __imp_CreateToolhelp32Snapshot │ │ │ │ │ +[13129](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000588 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.118.llvm.14048921605721191922 │ │ │ │ │ +[13130](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004738 anon.ce6f0c62864fa439afba1682d1475d3d.120.llvm.14048921605721191922 │ │ │ │ │ +[13131](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000000 __dll__ │ │ │ │ │ +[13132](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3d0 GetWindowsDirectoryW │ │ │ │ │ +[13133](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c10 __imp_str.0.llvm.12123695082059135366 │ │ │ │ │ +[13134](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e70 __imp_anon.34ba7072d2fdbfb72b844525ea0f1e7b.0.llvm.3215435228619338225 │ │ │ │ │ +[13135](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000870 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.94.llvm.9180192027238945235 │ │ │ │ │ +[13136](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000620 __imp_anon.a43af9cc4981a42dd00b013f8f55f130.0.llvm.13665133684747362110 │ │ │ │ │ +[13137](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ab0 __imp_WSARecv │ │ │ │ │ +[13138](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001db13 anon.07b55acb663eb35d742bae824872f75e.1.llvm.58757282566773765 │ │ │ │ │ +[13139](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006360 str.0.llvm.4036729494550109879 │ │ │ │ │ +[13140](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001e60 anon.577344e6c4a90a10ff600a929dedcba7.4.llvm.11685822864145163790 │ │ │ │ │ +[13141](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a38 __imp_realloc │ │ │ │ │ +[13142](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000029 _ZN3std2io5stdio19OUTPUT_CAPTURE_USED17he4f9ce513cba35dbE.0.llvm.11685822864145163790 │ │ │ │ │ +[13143](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000003998 anon.941f0f04b36aa440174d89d326747b6f.33.llvm.16620058351426711825 │ │ │ │ │ +[13144](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000900 __imp_SetFileAttributesW │ │ │ │ │ +[13145](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000057fd anon.2fc0b598515d6d45a6f7a748d37f9e68.12.llvm.9180192027238945235 │ │ │ │ │ +[13146](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000052b8 anon.a43af9cc4981a42dd00b013f8f55f130.115.llvm.13665133684747362110 │ │ │ │ │ +[13147](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a340 RtlCaptureContext │ │ │ │ │ +[13148](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000bb8 __imp_anon.3bd369ec61590d9272c591ac87029920.0.llvm.2123515186662715695 │ │ │ │ │ +[13149](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2180 _Unwind_Resume │ │ │ │ │ +[13150](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007e8 __imp_GetModuleHandleW │ │ │ │ │ +[13151](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009d0 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.13.llvm.10386673973210777259 │ │ │ │ │ +[13152](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e38 __imp_anon.07b55acb663eb35d742bae824872f75e.28.llvm.58757282566773765 │ │ │ │ │ +[13153](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b08 __imp_anon.567cec0599d353b04e33d4229b5f9b30.9.llvm.2628756017061842597 │ │ │ │ │ +[13154](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005870 anon.2fc0b598515d6d45a6f7a748d37f9e68.16.llvm.9180192027238945235 │ │ │ │ │ +[13155](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000047c8 anon.a43af9cc4981a42dd00b013f8f55f130.2.llvm.13665133684747362110 │ │ │ │ │ +[13156](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013a78 anon.1cd6cbb5d23cd003f709872fa6a8a6dd.8.llvm.9517595369394268439 │ │ │ │ │ +[13157](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000338 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.17.llvm.9587153679006429619 │ │ │ │ │ +[13158](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010e98 anon.567cec0599d353b04e33d4229b5f9b30.10.llvm.2628756017061842597 │ │ │ │ │ +[13159](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000057d9 anon.2fc0b598515d6d45a6f7a748d37f9e68.11.llvm.9180192027238945235 │ │ │ │ │ +[13160](sec 7)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x0000000000000158 __rust_alloc_error_handler_should_panic │ │ │ │ │ +[13161](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022be0 .refptr.__native_dllmain_reason │ │ │ │ │ +[13162](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000888 anon.08c341bb7f186daefc16bdd18254cc9c.7.llvm.2852608270795916942 │ │ │ │ │ +[13163](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a658 WSASocketW │ │ │ │ │ +[13164](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001e30 anon.577344e6c4a90a10ff600a929dedcba7.0.llvm.11685822864145163790 │ │ │ │ │ +[13165](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000001d0 anon.7ce35b53eeafc768de935b4fef3da959.12.llvm.1024159395525823541 │ │ │ │ │ +[13166](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000007f20 anon.75cd115d168aa5adc70873d7be22c67a.12.llvm.8768119154728042530 │ │ │ │ │ +[13167](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000250 __bss_end__ │ │ │ │ │ +[13168](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5e0 select │ │ │ │ │ +[13169](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000009a8 __imp_anon.5188eecf01c48ed8fcadadd01fcebeeb.2.llvm.10386673973210777259 │ │ │ │ │ +[13170](sec 11)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000008 _tls_end │ │ │ │ │ +[13171](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015318 anon.7a6259c55b9abecd4a2eb0873fc8b779.68.llvm.10283439849247210698 │ │ │ │ │ +[13172](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b68 __imp_anon.7ec0d7d1b51f482853d19890eaa43e99.13.llvm.4855701895496871646 │ │ │ │ │ +[13173](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015138 anon.7a6259c55b9abecd4a2eb0873fc8b779.49.llvm.10283439849247210698 │ │ │ │ │ +[13174](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000760 __imp_GetConsoleMode │ │ │ │ │ +[13175](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4f0 DuplicateHandle │ │ │ │ │ +[13176](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a478 GetEnvironmentVariableW │ │ │ │ │ +[13177](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005a10 anon.2fc0b598515d6d45a6f7a748d37f9e68.31.llvm.9180192027238945235 │ │ │ │ │ +[13178](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002f0 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.4.llvm.9587153679006429619 │ │ │ │ │ +[13179](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013506 anon.3bd369ec61590d9272c591ac87029920.6.llvm.2123515186662715695 │ │ │ │ │ +[13180](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000498 __imp_anon.941f0f04b36aa440174d89d326747b6f.43.llvm.16620058351426711825 │ │ │ │ │ +[13181](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a568 CopyFileExW │ │ │ │ │ +[13182](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000130 __imp_anon.03a7b1eb39947173efb71e48c5b540f4.5.llvm.10021583357862909 │ │ │ │ │ +[13183](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000950 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.44.llvm.4036729494550109879 │ │ │ │ │ +[13184](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004844 anon.a43af9cc4981a42dd00b013f8f55f130.12.llvm.13665133684747362110 │ │ │ │ │ +[13185](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d88 __imp_anon.df4f5fc91c1c1e84f2976758feaea474.14.llvm.17095335174290335670 │ │ │ │ │ +[13186](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000002708 anon.2d4ed69d03b8b00b295e2865b118c80a.3.llvm.9587153679006429619 │ │ │ │ │ +[13187](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ce0 anon.c5e06b7d2fb27e4271afbca860883ce8.27.llvm.12196597439006139751 │ │ │ │ │ +[13188](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c3168 LeaveCriticalSection │ │ │ │ │ +[13189](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000738 __imp_FindNextFileW │ │ │ │ │ +[13190](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000000c8 __imp_anon.c5e06b7d2fb27e4271afbca860883ce8.25.llvm.12196597439006139751 │ │ │ │ │ +[13191](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000868 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.93.llvm.9180192027238945235 │ │ │ │ │ +[13192](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007f8 __imp_GetProcAddress │ │ │ │ │ +[13193](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000de8 __imp_anon.07b55acb663eb35d742bae824872f75e.18.llvm.58757282566773765 │ │ │ │ │ +[13194](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ac8 __imp_WSAStartup │ │ │ │ │ +[13195](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002d0 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.0.llvm.9587153679006429619 │ │ │ │ │ +[13196](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004498 anon.ce6f0c62864fa439afba1682d1475d3d.82.llvm.14048921605721191922 │ │ │ │ │ +[13197](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000958 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.45.llvm.4036729494550109879 │ │ │ │ │ +[13198](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013845 anon.bb01d4b423a85a795a1692e8cd9c64e5.9.llvm.11285312269184381906 │ │ │ │ │ +[13199](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006b88 anon.5188eecf01c48ed8fcadadd01fcebeeb.13.llvm.10386673973210777259 │ │ │ │ │ +[13200](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000061f8 anon.2fc0b598515d6d45a6f7a748d37f9e68.91.llvm.9180192027238945235 │ │ │ │ │ +[13201](sec 10)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000020 __xi_z │ │ │ │ │ +[13202](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000ad8 __imp_anon.fc3e879c0d0583c039a7967db6c0c117.1.llvm.14670435032436802275 │ │ │ │ │ +[13203](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015116 anon.7a6259c55b9abecd4a2eb0873fc8b779.36.llvm.10283439849247210698 │ │ │ │ │ +[13204](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000af8 __imp_anon.567cec0599d353b04e33d4229b5f9b30.3.llvm.2628756017061842597 │ │ │ │ │ +[13205](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000200 __file_alignment__ │ │ │ │ │ +[13206](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a3f0 GetSystemDirectoryW │ │ │ │ │ +[13207](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b80 __imp__Unwind_GetIPInfo │ │ │ │ │ +[13208](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000270 __imp_anon.577344e6c4a90a10ff600a929dedcba7.51.llvm.11685822864145163790 │ │ │ │ │ +[13209](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000060 anon.7ce35b53eeafc768de935b4fef3da959.2.llvm.1024159395525823541 │ │ │ │ │ +[13210](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000938 __imp_anon.43b2cdb594d6435ffb5d037f4e7ac2c3.40.llvm.4036729494550109879 │ │ │ │ │ +[13211](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d68 anon.2611162d579b3e706d0c0f15accb8ea6.2.llvm.17987727548992354187 │ │ │ │ │ +[13212](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000194 __mingw_initltsdyn_force │ │ │ │ │ +[13213](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2f8 SetHandleInformation │ │ │ │ │ +[13214](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000012c8 anon.03a7b1eb39947173efb71e48c5b540f4.13.llvm.10021583357862909 │ │ │ │ │ +[13215](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4b8 FreeEnvironmentStringsW │ │ │ │ │ +[13216](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2368 memcpy │ │ │ │ │ +[13217](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000d08 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.66.llvm.10283439849247210698 │ │ │ │ │ +[13218](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000cc8 __imp_anon.7a6259c55b9abecd4a2eb0873fc8b779.45.llvm.10283439849247210698 │ │ │ │ │ +[13219](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c48 __imp_anon.1cd6cbb5d23cd003f709872fa6a8a6dd.31.llvm.9517595369394268439 │ │ │ │ │ +[13220](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000007f0 __imp_GetOverlappedResult │ │ │ │ │ +[13221](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000480 __imp_anon.941f0f04b36aa440174d89d326747b6f.32.llvm.16620058351426711825 │ │ │ │ │ +[13222](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002e0 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.2.llvm.9587153679006429619 │ │ │ │ │ +[13223](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c2348 _unlock │ │ │ │ │ +[13224](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000140 _ZN3std3sys3pal7windows3net11WSA_CLEANUP17he970e99e25d07381E.llvm.4036729494550109879 │ │ │ │ │ +[13225](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000510 __imp__ZN3std2rt7cleanup7CLEANUP17h07b9456e6b4bf964E.llvm.14048921605721191922 │ │ │ │ │ +[13226](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000002e8 __imp_anon.2d4ed69d03b8b00b295e2865b118c80a.3.llvm.9587153679006429619 │ │ │ │ │ +[13227](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000037a0 anon.941f0f04b36aa440174d89d326747b6f.14.llvm.16620058351426711825 │ │ │ │ │ +[13228](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000013952 anon.9de54bf691a285dd20d4e87e6b508fbd.8.llvm.12123695082059135366 │ │ │ │ │ +[13229](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005910 anon.2fc0b598515d6d45a6f7a748d37f9e68.21.llvm.9180192027238945235 │ │ │ │ │ +[13230](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dd50 anon.07b55acb663eb35d742bae824872f75e.31.llvm.58757282566773765 │ │ │ │ │ +[13231](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004340 anon.ce6f0c62864fa439afba1682d1475d3d.71.llvm.14048921605721191922 │ │ │ │ │ +[13232](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000c30 __imp_anon.9de54bf691a285dd20d4e87e6b508fbd.9.llvm.12123695082059135366 │ │ │ │ │ +[13233](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dcc9 anon.07b55acb663eb35d742bae824872f75e.23.llvm.58757282566773765 │ │ │ │ │ +[13234](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000670 __imp_AddVectoredExceptionHandler │ │ │ │ │ +[13235](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003e8 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.108.llvm.65172163764165323 │ │ │ │ │ +[13236](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000003f0 __imp_anon.edf9b0bdfd963b6a2ea99216811efd5e.109.llvm.65172163764165323 │ │ │ │ │ +[13237](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a380 MoveFileExW │ │ │ │ │ +[13238](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000010338 anon.d13ef5d19e380ff1a25cb10df774bd92.2.llvm.13995198208019911955 │ │ │ │ │ +[13239](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000c2388 strlen │ │ │ │ │ +[13240](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000840 __imp_HeapAlloc │ │ │ │ │ +[13241](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000948 __imp_SleepEx │ │ │ │ │ +[13242](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a5c0 shutdown │ │ │ │ │ +[13243](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000740 __imp_FlushFileBuffers │ │ │ │ │ +[13244](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000044b0 anon.ce6f0c62864fa439afba1682d1475d3d.83.llvm.14048921605721191922 │ │ │ │ │ +[13245](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006758 anon.43b2cdb594d6435ffb5d037f4e7ac2c3.41.llvm.4036729494550109879 │ │ │ │ │ +[13246](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000dd0 anon.2611162d579b3e706d0c0f15accb8ea6.4.llvm.17987727548992354187 │ │ │ │ │ +[13247](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001e50 anon.577344e6c4a90a10ff600a929dedcba7.3.llvm.11685822864145163790 │ │ │ │ │ +[13248](sec 7)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000160 _ZN10std_detect6detect5cache5CACHE17hf632556ed460aa26E │ │ │ │ │ +[13249](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000015360 anon.7a6259c55b9abecd4a2eb0873fc8b779.71.llvm.10283439849247210698 │ │ │ │ │ +[13250](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004c88 anon.a43af9cc4981a42dd00b013f8f55f130.66.llvm.13665133684747362110 │ │ │ │ │ +[13251](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4f8 DeviceIoControl │ │ │ │ │ +[13252](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000019bc __lib64_libkernel32_a_iname │ │ │ │ │ +[13253](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000858 __imp_anon.2fc0b598515d6d45a6f7a748d37f9e68.91.llvm.9180192027238945235 │ │ │ │ │ +[13254](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000069e0 anon.5188eecf01c48ed8fcadadd01fcebeeb.0.llvm.10386673973210777259 │ │ │ │ │ +[13255](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000003c _head_lib64_libmsvcrt_def_a │ │ │ │ │ +[13256](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000000745f anon.5188eecf01c48ed8fcadadd01fcebeeb.102.llvm.10386673973210777259 │ │ │ │ │ +[13257](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000001dc20 anon.07b55acb663eb35d742bae824872f75e.12.llvm.58757282566773765 │ │ │ │ │ +[13258](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000060f1 anon.2fc0b598515d6d45a6f7a748d37f9e68.84.llvm.9180192027238945235 │ │ │ │ │ +[13259](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000229a0 __dyn_tls_init_callback │ │ │ │ │ +[13260](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000580 __imp_anon.ce6f0c62864fa439afba1682d1475d3d.117.llvm.14048921605721191922 │ │ │ │ │ +[13261](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000008f8 __imp_SetEnvironmentVariableW │ │ │ │ │ +[13262](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a2c8 SwitchToThread │ │ │ │ │ +[13263](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000001000 __size_of_stack_commit__ │ │ │ │ │ +[13264](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000004720 anon.ce6f0c62864fa439afba1682d1475d3d.119.llvm.14048921605721191922 │ │ │ │ │ +[13265](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4e8 ExitProcess │ │ │ │ │ +[13266](sec -1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000160 __dll_characteristics__ │ │ │ │ │ +[13267](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000022bf0 .refptr.__native_startup_lock │ │ │ │ │ +[13268](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x00000000000015b0 anon.03a7b1eb39947173efb71e48c5b540f4.51.llvm.10021583357862909 │ │ │ │ │ +[13269](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a30 __imp_memset │ │ │ │ │ +[13270](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000e78 __imp_anon.34ba7072d2fdbfb72b844525ea0f1e7b.1.llvm.3215435228619338225 │ │ │ │ │ +[13271](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000a78 anon.c5e06b7d2fb27e4271afbca860883ce8.6.llvm.12196597439006139751 │ │ │ │ │ +[13272](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000012e20 anon.7ec0d7d1b51f482853d19890eaa43e99.0.llvm.4855701895496871646 │ │ │ │ │ [13273](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a620 getaddrinfo │ │ │ │ │ [13274](sec 1)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x000000000006a4e0 FindClose │ │ │ │ │ [13275](sec 9)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000b38 __imp_select │ │ │ │ │ [13276](sec 2)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000000048 __imp_anon.08c341bb7f186daefc16bdd18254cc9c.3.llvm.2852608270795916942 │ │ │ │ │ [13277](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000005320 anon.a43af9cc4981a42dd00b013f8f55f130.118.llvm.13665133684747362110 │ │ │ │ │ [13278](sec 1)(fl 0x00)(ty 20)(scl 2) (nx 0) 0x00000000000c2340 _lock │ │ │ │ │ [13279](sec 3)(fl 0x00)(ty 0)(scl 2) (nx 0) 0x0000000000006280 anon.2fc0b598515d6d45a6f7a748d37f9e68.97.llvm.9180192027238945235 │ │ │ │ │ @@ -3039268,25 +3039268,25 @@ │ │ │ │ │ 1808cec0b: jo 1808cec6e <__bss_end__+0x27a1e> │ │ │ │ │ 1808cec0d: outsb %ds:(%rsi),(%dx) │ │ │ │ │ 1808cec0e: .byte 0x69 │ │ │ │ │ 1808cec0f: movsxd (%rax),%eax │ │ │ │ │ │ │ │ │ │ Disassembly of section .idata: │ │ │ │ │ │ │ │ │ │ -00000001808cf000 <_head__tmp_rustcBv6EAf_api_ms_win_core_synch_l1_2_0_lib>: │ │ │ │ │ +00000001808cf000 <_head__tmp_rustcpdeyFw_api_ms_win_core_synch_l1_2_0_lib>: │ │ │ │ │ 1808cf000: mov $0x8cf0,%eax │ │ │ │ │ 1808cf005: add %al,(%rax) │ │ │ │ │ 1808cf007: add %al,(%rax) │ │ │ │ │ 1808cf009: add %al,(%rax) │ │ │ │ │ 1808cf00b: add %dl,%al │ │ │ │ │ 1808cf00d: (bad) │ │ │ │ │ 1808cf00e: lea (%rax),%eax │ │ │ │ │ 1808cf010: rex testb $0x0,0x8cf0d8(%rax,%rax,1) │ │ │ │ │ │ │ │ │ │ -00000001808cf014 <_head__tmp_rustcBv6EAf_bcryptprimitives_lib>: │ │ │ │ │ +00000001808cf014 <_head__tmp_rustcpdeyFw_bcryptprimitives_lib>: │ │ │ │ │ 1808cf014: fdiv %st(0),%st │ │ │ │ │ 1808cf016: mov %es,(%rax) │ │ │ │ │ ... │ │ │ │ │ 1808cf020: clc │ │ │ │ │ 1808cf021: (bad) │ │ │ │ │ 1808cf022: lea (%rax),%eax │ │ │ │ │ 1808cf024: (bad) │ │ │ │ │ @@ -3042807,39 +3042807,39 @@ │ │ │ │ │ 00000001808d0758 <.idata$6>: │ │ │ │ │ 1808d0758: or $0x6e555f00,%eax │ │ │ │ │ 1808d075d: ja 1808d07c8 <.idata$7> │ │ │ │ │ 1808d075f: outsb %ds:(%rsi),(%dx) │ │ │ │ │ 1808d0760: fs pop %rdi │ │ │ │ │ 1808d0762: rex.RXB │ │ │ │ │ 1808d0763: gs je 1808d07ba <.idata$6+0x6> │ │ │ │ │ - 1808d0766: gs js 1808d07dd <___tmp_rustcBv6EAf_api_ms_win_core_synch_l1_2_0_lib_iname+0xd> │ │ │ │ │ + 1808d0766: gs js 1808d07dd <___tmp_rustcpdeyFw_api_ms_win_core_synch_l1_2_0_lib_iname+0xd> │ │ │ │ │ 1808d0769: push %rdx │ │ │ │ │ 1808d076a: gs insb (%dx),%es:(%rdi) │ │ │ │ │ 1808d076c: rex.X (bad) │ │ │ │ │ - 1808d076e: jae 1808d07d5 <___tmp_rustcBv6EAf_api_ms_win_core_synch_l1_2_0_lib_iname+0x5> │ │ │ │ │ + 1808d076e: jae 1808d07d5 <___tmp_rustcpdeyFw_api_ms_win_core_synch_l1_2_0_lib_iname+0x5> │ │ │ │ │ 1808d0770: add %al,(%rax) │ │ │ │ │ ... │ │ │ │ │ │ │ │ │ │ 00000001808d0774 <.idata$6>: │ │ │ │ │ 1808d0774: (bad) │ │ │ │ │ 1808d0775: add %bl,0x55(%rdi) │ │ │ │ │ 1808d0778: outsb %ds:(%rsi),(%dx) │ │ │ │ │ - 1808d0779: ja 1808d07e4 <___tmp_rustcBv6EAf_api_ms_win_core_synch_l1_2_0_lib_iname+0x14> │ │ │ │ │ + 1808d0779: ja 1808d07e4 <___tmp_rustcpdeyFw_api_ms_win_core_synch_l1_2_0_lib_iname+0x14> │ │ │ │ │ 1808d077b: outsb %ds:(%rsi),(%dx) │ │ │ │ │ 1808d077c: fs pop %rdi │ │ │ │ │ 1808d077e: push %rdx │ │ │ │ │ 1808d077f: (bad) │ │ │ │ │ 1808d0780: imul $0x65637845,0x65(%rbx),%esi │ │ │ │ │ - 1808d0787: jo 1808d07fd <___tmp_rustcBv6EAf_bcryptprimitives_lib_iname+0x5> │ │ │ │ │ + 1808d0787: jo 1808d07fd <___tmp_rustcpdeyFw_bcryptprimitives_lib_iname+0x5> │ │ │ │ │ 1808d0789: imul $0x0,0x6e(%rdi),%ebp │ │ │ │ │ │ │ │ │ │ 00000001808d0790 <.idata$6>: │ │ │ │ │ 1808d0790: ltr 0x55(%rdi) │ │ │ │ │ 1808d0794: outsb %ds:(%rsi),(%dx) │ │ │ │ │ - 1808d0795: ja 1808d0800 <___tmp_rustcBv6EAf_bcryptprimitives_lib_iname+0x8> │ │ │ │ │ + 1808d0795: ja 1808d0800 <___tmp_rustcpdeyFw_bcryptprimitives_lib_iname+0x8> │ │ │ │ │ 1808d0797: outsb %ds:(%rsi),(%dx) │ │ │ │ │ 1808d0798: fs pop %rdi │ │ │ │ │ 1808d079a: push %rdx │ │ │ │ │ 1808d079b: gs jae 1808d0813 <.idata$7+0x3> │ │ │ │ │ 1808d079e: insl (%dx),%es:(%rdi) │ │ │ │ │ 1808d079f: add %al,%gs:(%rax) │ │ │ │ │ ... │ │ │ │ │ @@ -3042849,28 +3042849,28 @@ │ │ │ │ │ 1808d07a6: pop %rdi │ │ │ │ │ 1808d07a7: push %rbp │ │ │ │ │ 1808d07a8: outsb %ds:(%rsi),(%dx) │ │ │ │ │ 1808d07a9: ja 1808d0814 <.idata$7> │ │ │ │ │ 1808d07ab: outsb %ds:(%rsi),(%dx) │ │ │ │ │ 1808d07ac: fs pop %rdi │ │ │ │ │ 1808d07ae: push %rbx │ │ │ │ │ - 1808d07af: gs je 1808d07f9 <___tmp_rustcBv6EAf_bcryptprimitives_lib_iname+0x1> │ │ │ │ │ + 1808d07af: gs je 1808d07f9 <___tmp_rustcpdeyFw_bcryptprimitives_lib_iname+0x1> │ │ │ │ │ 1808d07b2: push %rdx │ │ │ │ │ ... │ │ │ │ │ │ │ │ │ │ 00000001808d07b4 <.idata$6>: │ │ │ │ │ 1808d07b4: adc (%rax),%al │ │ │ │ │ 1808d07b6: pop %rdi │ │ │ │ │ 1808d07b7: push %rbp │ │ │ │ │ 1808d07b8: outsb %ds:(%rsi),(%dx) │ │ │ │ │ 1808d07b9: ja 1808d0824 <.idata$7> │ │ │ │ │ 1808d07bb: outsb %ds:(%rsi),(%dx) │ │ │ │ │ 1808d07bc: fs pop %rdi │ │ │ │ │ 1808d07be: push %rbx │ │ │ │ │ - 1808d07bf: gs je 1808d080b <___tmp_rustcBv6EAf_bcryptprimitives_lib_iname+0x13> │ │ │ │ │ + 1808d07bf: gs je 1808d080b <___tmp_rustcpdeyFw_bcryptprimitives_lib_iname+0x13> │ │ │ │ │ 1808d07c2: push %rax │ │ │ │ │ ... │ │ │ │ │ │ │ │ │ │ 00000001808d07c4 <.idata$7>: │ │ │ │ │ 1808d07c4: add %dh,%al │ │ │ │ │ 1808d07c6: mov %es,(%rax) │ │ │ │ │ │ │ │ │ │ @@ -3042878,15 +3042878,15 @@ │ │ │ │ │ 1808d07c8: add %dh,%al │ │ │ │ │ 1808d07ca: mov %es,(%rax) │ │ │ │ │ │ │ │ │ │ 00000001808d07cc <.idata$7>: │ │ │ │ │ 1808d07cc: add %dh,%al │ │ │ │ │ 1808d07ce: mov %es,(%rax) │ │ │ │ │ │ │ │ │ │ -00000001808d07d0 <___tmp_rustcBv6EAf_api_ms_win_core_synch_l1_2_0_lib_iname>: │ │ │ │ │ +00000001808d07d0 <___tmp_rustcpdeyFw_api_ms_win_core_synch_l1_2_0_lib_iname>: │ │ │ │ │ 1808d07d0: (bad) │ │ │ │ │ 1808d07d1: jo 1808d083c <.idata$7> │ │ │ │ │ 1808d07d3: sub $0x772d736d,%eax │ │ │ │ │ 1808d07d8: imul $0x65726f63,0x2d(%rsi),%ebp │ │ │ │ │ 1808d07df: sub $0x636e7973,%eax │ │ │ │ │ 1808d07e4: push $0x2d316c2d │ │ │ │ │ 1808d07e9: xor 0x6c642e30(%rip),%ch # 1ecf1361f <.debug_rnglists+0x6b77c55f> │ │ │ │ │ @@ -3042894,15 +3042894,15 @@ │ │ │ │ │ 1808d07f0: add %al,(%rax) │ │ │ │ │ ... │ │ │ │ │ │ │ │ │ │ 00000001808d07f4 <.idata$7>: │ │ │ │ │ 1808d07f4: adc $0xf0,%al │ │ │ │ │ 1808d07f6: mov %es,(%rax) │ │ │ │ │ │ │ │ │ │ -00000001808d07f8 <___tmp_rustcBv6EAf_bcryptprimitives_lib_iname>: │ │ │ │ │ +00000001808d07f8 <___tmp_rustcpdeyFw_bcryptprimitives_lib_iname>: │ │ │ │ │ 1808d07f8: (bad) │ │ │ │ │ 1808d07fa: jb 1808d0875 <.idata$7+0x1> │ │ │ │ │ 1808d07fc: jo 1808d0872 <.idata$7+0x2> │ │ │ │ │ 1808d07fe: jo 1808d0872 <.idata$7+0x2> │ │ │ │ │ 1808d0800: imul $0x65766974,0x69(%rbp),%ebp │ │ │ │ │ 1808d0807: jae 1808d0837 <.idata$7+0x3> │ │ │ │ │ 1808d0809: fs insb (%dx),%es:(%rdi) │ │ │ │ │ @@ -4194295,8 +4194295,8 @@ │ │ │ │ │ 180b95a5a: (bad) │ │ │ │ │ 180b95a5b: shrb 0x171a0019(%rdx) │ │ │ │ │ 180b95a61: adc %bl,(%rdx) │ │ │ │ │ 180b95a63: add %dh,%dl │ │ │ │ │ 180b95a65: bndldx (%rax),%bnd0 │ │ │ │ │ 180b95a68: sbb 0x8(%rdx),%ch │ │ │ │ │ 180b95a6b: mov 0xa010001(%rbx),%bl │ │ │ │ │ -[ Too much input for diff (SHA256: 344bf2998d6f5dbaa23abbe382dddbcbfd944fc0df3a491917361d6e962f2ed9) ] │ │ │ │ │ +[ Too much input for diff (SHA256: 99ec874e24acb40de6cfb0c688497c773f8e2fd4088979c5dea6a7fa08c22361) ] ├── rust-web-doc_1.78.0+dfsg1-2~deb12u3_all.deb │ ├── file list │ │ @@ -1,3 +1,3 @@ │ │ -rw-r--r-- 0 0 0 4 2024-08-28 14:44:23.000000 debian-binary │ │ --rw-r--r-- 0 0 0 763180 2024-08-28 14:44:23.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 19434036 2024-08-28 14:44:23.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 763236 2024-08-28 14:44:23.000000 control.tar.xz │ │ +-rw-r--r-- 0 0 0 19271176 2024-08-28 14:44:23.000000 data.tar.xz │ ├── control.tar.xz │ │ ├── control.tar │ │ │ ├── ./control │ │ │ │ @@ -1,13 +1,13 @@ │ │ │ │ Package: rust-web-doc │ │ │ │ Source: rustc-web │ │ │ │ Version: 1.78.0+dfsg1-2~deb12u3 │ │ │ │ Architecture: all │ │ │ │ Maintainer: Debian Rust Maintainers │ │ │ │ -Installed-Size: 567591 │ │ │ │ +Installed-Size: 569595 │ │ │ │ Depends: libjs-jquery, libjs-highlight.js, libjs-mathjax, fonts-open-sans, fonts-font-awesome │ │ │ │ Recommends: cargo-web-doc │ │ │ │ Conflicts: rust-doc, rust-mozilla-doc │ │ │ │ Section: doc │ │ │ │ Priority: optional │ │ │ │ Homepage: http://www.rust-lang.org/ │ │ │ │ Description: Rust systems programming language - Documentation │ │ │ ├── ./md5sums │ │ │ │ ├── ./md5sums │ │ │ │ │┄ Files differ │ ├── data.tar.xz │ │ ├── data.tar │ │ │ ├── file list │ │ │ │ @@ -10,53 +10,53 @@ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 8565 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/changelog.Debian.gz │ │ │ │ -rw-r--r-- 0 root (0) root (0) 181976 2024-04-29 14:03:23.000000 ./usr/share/doc/rust-web-doc/changelog.gz │ │ │ │ -rw-r--r-- 0 root (0) root (0) 120683 2024-06-24 05:36:38.000000 ./usr/share/doc/rust-web-doc/copyright │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 19220 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/all.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7113 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.alloc.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 6856 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.alloc_zeroed.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5688 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.dealloc.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 6352 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.handle_alloc_error.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5906 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.realloc.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 7167 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.alloc.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6910 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.alloc_zeroed.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5742 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.dealloc.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6433 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.handle_alloc_error.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6041 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.realloc.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 8501 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 209 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 35478 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.AllocError.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 37581 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.Global.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 55924 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.Layout.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 36744 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.LayoutError.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 34558 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/trait.Allocator.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 24449 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/trait.GlobalAlloc.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5114 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/type.LayoutErr.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 38367 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.AllocError.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 40146 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.Global.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 59812 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.Layout.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 39633 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.LayoutError.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 36286 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/trait.Allocator.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 25178 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/trait.GlobalAlloc.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5141 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/alloc/type.LayoutErr.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/borrow/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 165792 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/borrow/enum.Cow.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 177969 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/borrow/enum.Cow.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 5657 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/borrow/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 81 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/borrow/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 24087 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/borrow/trait.Borrow.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 11464 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/borrow/trait.BorrowMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 14320 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/borrow/trait.ToOwned.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 24816 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/borrow/trait.Borrow.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 11923 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/borrow/trait.BorrowMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 14482 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/borrow/trait.ToOwned.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/boxed/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 15351 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/boxed/index.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 15432 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/boxed/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 52 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/boxed/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 449983 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/boxed/struct.Box.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 42115 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/boxed/struct.ThinBox.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 487351 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/boxed/struct.Box.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 44950 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/boxed/struct.ThinBox.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/boxed/thin/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 432 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/boxed/thin/struct.ThinBox.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 20331 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 116 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 123398 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.BinaryHeap.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 149373 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.Drain.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 139001 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.DrainSorted.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 154699 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.IntoIter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 143314 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.IntoIterSorted.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 148465 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.Iter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 29522 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.PeekMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 127502 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.BinaryHeap.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 166629 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.Drain.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 154865 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.DrainSorted.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 172435 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.IntoIter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 159490 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.IntoIterSorted.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 165985 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.Iter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 31298 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.PeekMut.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/map/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/map/entry/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 504 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/map/entry/enum.Entry.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 544 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/map/entry/struct.OccupiedEntry.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 544 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/map/entry/struct.OccupiedError.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 536 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/map/entry/struct.VacantEntry.html │ │ │ │ @@ -83,255 +83,255 @@ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 528 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/set/struct.Intersection.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 512 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/set/struct.IntoIter.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 496 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/set/struct.Iter.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 500 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/set/struct.Range.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 556 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/set/struct.SymmetricDifference.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 500 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree/set/struct.Union.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 38707 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/enum.Entry.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 40699 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/enum.Entry.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 11206 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 277 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 202416 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.BTreeMap.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 32520 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Cursor.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 40536 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.CursorMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 39724 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.CursorMutKey.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 134595 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.ExtractIf.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 150904 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IntoIter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 152747 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IntoKeys.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 151269 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IntoValues.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 153811 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Iter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 148637 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IterMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 153007 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Keys.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 39521 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.OccupiedEntry.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 33958 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.OccupiedError.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 152603 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Range.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 145304 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.RangeMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 36485 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.UnorderedKeyError.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 29936 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.VacantEntry.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 151225 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Values.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 146827 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.ValuesMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 212304 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.BTreeMap.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 34464 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Cursor.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 42576 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.CursorMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 41764 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.CursorMutKey.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 150675 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.ExtractIf.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 168736 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IntoIter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 170483 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IntoKeys.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 168813 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IntoValues.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 171955 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Iter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 166373 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IterMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 170959 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Keys.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 41273 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.OccupiedEntry.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 36094 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.OccupiedError.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 170315 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Range.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 162560 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.RangeMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 38621 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.UnorderedKeyError.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 31664 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.VacantEntry.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 168889 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Values.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 164035 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.ValuesMut.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 7246 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 143 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 156736 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.BTreeSet.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 136107 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Difference.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 133979 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.ExtractIf.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 136245 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Intersection.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 148228 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.IntoIter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 152263 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Iter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 151095 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Range.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 134845 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.SymmetricDifference.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 133874 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Union.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 33657 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/enum.TryReserveErrorKind.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 164704 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.BTreeSet.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 152187 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Difference.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 149891 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.ExtractIf.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 152325 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Intersection.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 165772 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.IntoIter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 170119 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Iter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 168519 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Range.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 150709 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.SymmetricDifference.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 149738 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Union.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 35655 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/enum.TryReserveErrorKind.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 7964 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/index.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 7262 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 110 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 36916 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.Cursor.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 52206 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.CursorMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 131589 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.ExtractIf.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 152977 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.IntoIter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 150367 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.Iter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 144852 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.IterMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 124914 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.LinkedList.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 38860 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.Cursor.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 54150 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.CursorMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 147117 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.ExtractIf.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 170689 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.IntoIter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 167959 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.Iter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 162084 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.IterMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 130770 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.LinkedList.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 157 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 38061 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/struct.TryReserveError.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 40572 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/struct.TryReserveError.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/drain/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 500 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/drain/struct.Drain.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 6447 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/index.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/into_iter/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 512 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/into_iter/struct.IntoIter.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/iter/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 496 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/iter/struct.Iter.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/iter_mut/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 508 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/iter_mut/struct.IterMut.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 83 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 149446 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.Drain.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 150761 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.IntoIter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 148399 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.Iter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 143470 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.IterMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 231680 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.VecDeque.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 166774 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.Drain.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 168041 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.IntoIter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 165679 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.Iter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 160366 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.IterMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 241064 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.VecDeque.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 6311 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 97 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 130313 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.CString.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 41577 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.FromVecWithNulError.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 38243 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.IntoStringError.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 39864 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.NulError.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 11555 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/index.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 136673 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.CString.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 43785 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.FromVecWithNulError.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 40331 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.IntoStringError.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 42024 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.NulError.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 11798 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 62 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 128765 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/struct.CString.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 135920 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/ffi/struct.CString.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 4593 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/derive.Debug.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 28733 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/enum.Alignment.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 6710 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/fn.format.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7527 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/fn.write.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 62701 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/index.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 4620 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/derive.Debug.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 30974 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/enum.Alignment.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6737 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/fn.format.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 7635 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/fn.write.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 62971 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 332 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 35017 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.Arguments.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 30951 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugList.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 40524 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugMap.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 31045 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugSet.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 32895 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugStruct.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 28930 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugTuple.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 47867 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.Error.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 78424 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.Formatter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 28546 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.FormatterFn.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 18759 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Binary.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 239022 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Debug.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 56727 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Display.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 17422 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.LowerExp.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 18239 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.LowerHex.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 17861 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Octal.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 16289 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Pointer.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 17423 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.UpperExp.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 18239 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.UpperHex.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 16974 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Write.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 8035 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/type.Result.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 11350 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/index.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 37204 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.Arguments.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 32679 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugList.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 42441 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugMap.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 32773 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugSet.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 34704 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugStruct.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 30604 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugTuple.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 52592 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.Error.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 81475 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.Formatter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 30625 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.FormatterFn.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 20028 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Binary.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 255438 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Debug.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 60723 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Display.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 18502 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.LowerExp.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 19400 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.LowerHex.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 19022 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Octal.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 17099 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Pointer.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 18503 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.UpperExp.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 19400 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.UpperHex.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 17730 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Write.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 8170 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/fmt/type.Result.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 11410 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 340 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/macro.format!.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7723 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/macro.format.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 7813 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/macro.format.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 328 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/macro.vec!.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7383 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/macro.vec.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 7413 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/macro.vec.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/rc/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 25988 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/rc/index.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 26258 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/rc/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 59 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/rc/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 220346 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/rc/struct.Rc.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 31531 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/rc/struct.UniqueRc.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 66053 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/rc/struct.Weak.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 229337 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/rc/struct.Rc.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 33286 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/rc/struct.UniqueRc.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 68888 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/rc/struct.Weak.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 157 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/sidebar-items1.78.0.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 4933 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_mut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 9024 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_mut_ptr_range.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 8563 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_ptr_range.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 11259 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_raw_parts.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7058 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_raw_parts_mut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 4824 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_ref.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 10191 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.range.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 8722 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.try_range.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 16852 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/index.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5014 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_mut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 9240 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_mut_ptr_range.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 8779 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_ptr_range.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 11448 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_raw_parts.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 7247 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_raw_parts_mut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 4905 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_ref.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 10569 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.range.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 9019 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.try_range.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 16933 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 539 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 155767 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ArrayChunks.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 149541 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ArrayChunksMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 152001 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ArrayWindows.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 142687 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunkBy.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 142603 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunkByMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 148874 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Chunks.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 155883 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunksExact.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 147552 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunksExactMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 142890 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunksMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 147908 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.EscapeAscii.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 157587 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Iter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 159621 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.IterMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 151782 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunks.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 155995 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunksExact.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 147634 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunksExactMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 145594 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunksMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 148344 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplit.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 142482 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplitMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 128811 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplitN.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 128712 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplitNMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 148917 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Split.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 149501 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitInclusive.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 143560 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitInclusiveMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 140245 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 128676 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitN.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 128577 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitNMut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 148679 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Windows.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 12606 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/trait.Concat.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 11576 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/trait.Join.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 39878 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/trait.SliceIndex.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 176665 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ArrayChunks.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 169818 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ArrayChunksMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 172548 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ArrayWindows.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 162424 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunkBy.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 162286 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunkByMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 169259 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Chunks.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 176349 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunksExact.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 167478 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunksExactMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 162735 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunksMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 167618 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.EscapeAscii.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 178566 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Iter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 180168 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.IterMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 172167 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunks.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 176461 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunksExact.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 167560 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunksExactMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 165439 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunksMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 168675 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplit.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 162192 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplitMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 146874 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplitN.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 146721 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplitNMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 169410 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Split.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 169832 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitInclusive.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 163270 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitInclusiveMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 159955 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 146739 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitN.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 146586 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitNMut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 169064 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Windows.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 12903 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/trait.Concat.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 11981 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/trait.Join.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 42740 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/slice/trait.SliceIndex.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5977 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_boxed_utf8_unchecked.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5906 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_raw_parts.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5944 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_raw_parts_mut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 10249 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7730 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8_mut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 6333 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8_unchecked.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 6289 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8_unchecked_mut.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 16363 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/index.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6031 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_boxed_utf8_unchecked.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6041 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_raw_parts.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6079 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_raw_parts_mut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 10492 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 7838 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8_mut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6414 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8_unchecked.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6370 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8_unchecked_mut.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 16930 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/index.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 31510 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/enum.SearchStep.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 12952 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/index.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 33694 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/enum.SearchStep.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 13096 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 245 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 37503 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharArrayRefSearcher.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 37046 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharArraySearcher.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 39260 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharPredicateSearcher.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 35542 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharSearcher.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 36147 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharSliceSearcher.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 35001 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.StrSearcher.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 10669 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.DoubleEndedSearcher.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 37349 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.Pattern.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 16751 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.ReverseSearcher.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 18216 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.Searcher.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 39975 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharArrayRefSearcher.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 39518 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharArraySearcher.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 42044 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharPredicateSearcher.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 37726 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharSearcher.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 38331 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharSliceSearcher.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 37161 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.StrSearcher.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 10981 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.DoubleEndedSearcher.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 38885 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.Pattern.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 17399 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.ReverseSearcher.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 18960 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.Searcher.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 569 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 147283 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Bytes.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 146113 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.CharIndices.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 143835 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Chars.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 133871 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EncodeUtf16.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 136712 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EscapeDebug.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 136900 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EscapeDefault.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 136900 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EscapeUnicode.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 144352 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Lines.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 141993 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.LinesAny.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 145941 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.MatchIndices.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 145895 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Matches.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 34699 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.ParseBoolError.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 147320 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RMatchIndices.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 147274 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RMatches.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 147282 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RSplit.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 138279 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RSplitN.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 148118 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RSplitTerminator.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 145896 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Split.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 148781 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitAsciiWhitespace.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 149921 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitInclusive.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 136898 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitN.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 146732 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitTerminator.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 148333 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitWhitespace.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 32784 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Utf8Chunk.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 137229 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Utf8Chunks.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 41929 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Utf8Error.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 47370 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/trait.FromStr.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 167560 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Bytes.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 165985 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.CharIndices.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 163518 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Chars.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 151907 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EncodeUtf16.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 154856 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EscapeDebug.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 155044 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EscapeDefault.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 155044 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EscapeUnicode.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 164062 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Lines.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 161595 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.LinesAny.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 165246 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.MatchIndices.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 165092 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Matches.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 37534 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.ParseBoolError.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 166625 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RMatchIndices.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 166471 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RMatches.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 166587 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RSplit.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 156396 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RSplitN.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 167423 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RSplitTerminator.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 165201 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Split.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 168491 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitAsciiWhitespace.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 169253 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitInclusive.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 155015 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitN.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 166037 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitTerminator.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 168043 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitWhitespace.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 35160 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Utf8Chunk.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 155238 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Utf8Chunks.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 45007 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Utf8Error.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 50826 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/str/trait.FromStr.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 9968 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/index.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 9995 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 129 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 144454 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/struct.Drain.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 28200 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/struct.FromUtf16Error.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 42727 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/struct.FromUtf8Error.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 539972 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/struct.String.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7862 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/trait.ToString.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5396 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/type.ParseError.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 163462 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/struct.Drain.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 30090 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/struct.FromUtf16Error.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 45346 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/struct.FromUtf8Error.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 563489 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/struct.String.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 7889 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/trait.ToString.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5450 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/string/type.ParseError.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/sync/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 6028 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/sync/index.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6055 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/sync/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 49 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/sync/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 252380 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/sync/struct.Arc.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 65887 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/sync/struct.Weak.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 262802 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/sync/struct.Arc.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 69019 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/sync/struct.Weak.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/task/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 5698 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/task/index.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 54 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/task/sidebar-items1.78.0.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 14741 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/task/trait.LocalWake.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 13127 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/task/trait.Wake.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 14768 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/task/trait.LocalWake.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 13289 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/task/trait.Wake.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/drain/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 416 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/drain/struct.Drain.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/extract_if/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 432 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/extract_if/struct.ExtractIf.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 10027 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/index.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 10081 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/index.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/into_iter/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 428 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/into_iter/struct.IntoIter.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 82 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/sidebar-items1.78.0.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/splice/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 420 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/splice/struct.Splice.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 154921 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.Drain.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 134714 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.ExtractIf.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 158769 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.IntoIter.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 150235 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.Splice.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 786200 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.Vec.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 174577 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.Drain.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 152615 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.ExtractIf.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 178749 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.IntoIter.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 170377 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.Splice.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 819950 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.Vec.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/book/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 72 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/book/.nojekyll │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/book/2018-edition/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 72 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/book/2018-edition/.nojekyll │ │ │ │ -rw-r--r-- 0 root (0) root (0) 25761 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/book/2018-edition/appendix-00.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 25767 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/book/2018-edition/appendix-01-keywords.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 25853 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/book/2018-edition/appendix-02-operators.html │ │ │ │ @@ -35628,34 +35628,34 @@ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/alloc/global/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 413 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/alloc/global/trait.GlobalAlloc.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 666 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/alloc/trait.Allocator.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/any/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/any/trait.Any.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/async_iter/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/async_iter/async_iter/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 860 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/async_iter/async_iter/trait.AsyncIterator.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 992 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/async_iter/async_iter/trait.AsyncIterator.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/async_iter/async_iter/trait.IntoAsyncIterator.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/borrow/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 3859 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/borrow/trait.Borrow.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 1436 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/borrow/trait.BorrowMut.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 4090 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/borrow/trait.Borrow.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 1535 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/borrow/trait.BorrowMut.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/clone/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 43470 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/clone/trait.Clone.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 46308 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/clone/trait.Clone.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 18893 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.Eq.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7858 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.Ord.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 58796 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.PartialEq.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 28369 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.PartialOrd.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 20015 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.Eq.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 8749 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.Ord.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 62723 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.PartialEq.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 29260 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.PartialOrd.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/num/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/num/trait.FloatToInt.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 1869 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.AsMut.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 11666 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.AsRef.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 81117 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.From.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 2100 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.AsMut.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 12491 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.AsRef.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 89301 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.From.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.Into.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 4158 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.TryFrom.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 4752 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.TryFrom.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.TryInto.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/cast/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/cast/trait.SimdCast.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/lane_count/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/lane_count/trait.SupportedLaneCount.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/masks/ │ │ │ │ @@ -35680,127 +35680,127 @@ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/simd/ptr/mut_ptr/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/simd/ptr/mut_ptr/trait.SimdMutPtr.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/to_bytes/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/to_bytes/trait.ToBytes.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/vector/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/core_simd/vector/trait.SimdElement.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/default/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 19401 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/default/trait.Default.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 21117 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/default/trait.Default.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/error/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 9379 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/error/trait.Error.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 9940 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/error/trait.Error.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 202 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Binary.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 94509 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Debug.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 18060 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Display.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 95862 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Debug.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 18291 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Display.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 202 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.LowerExp.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 202 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.LowerHex.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 202 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Octal.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 1579 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Pointer.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 1678 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Pointer.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 202 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.UpperExp.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 202 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.UpperHex.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 638 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Write.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/future/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/future/future/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 908 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/future/future/trait.Future.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 1040 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/future/future/trait.Future.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/future/into_future/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/future/into_future/trait.IntoFuture.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/hash/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 468 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/hash/trait.BuildHasher.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 9528 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/hash/trait.Hash.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 1034 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/hash/trait.Hasher.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 10419 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/hash/trait.Hash.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 1133 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/hash/trait.Hasher.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/range/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/range/trait.Step.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/accum/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/accum/trait.Product.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/accum/trait.Sum.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/collect/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 15580 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/collect/trait.Extend.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 11879 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/collect/trait.FromIterator.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 11178 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/collect/trait.IntoIterator.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 17164 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/collect/trait.Extend.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 13133 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/collect/trait.FromIterator.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 11871 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/collect/trait.IntoIterator.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/double_ended/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 13707 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/double_ended/trait.DoubleEndedIterator.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 14862 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/double_ended/trait.DoubleEndedIterator.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/exact_size/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 16874 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/exact_size/trait.ExactSizeIterator.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 18029 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/exact_size/trait.ExactSizeIterator.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/iterator/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 31815 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/iterator/trait.Iterator.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 34059 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/iterator/trait.Iterator.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/marker/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 25103 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/marker/trait.FusedIterator.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 3209 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/marker/trait.TrustedLen.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 26984 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/marker/trait.FusedIterator.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 3506 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/marker/trait.TrustedLen.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/marker/trait.TrustedStep.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.ConstParamTy.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 11445 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Copy.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 96016 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Freeze.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 111359 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Send.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 11478 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Copy.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 99778 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Freeze.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 117959 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Send.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 666 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Sized.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 15006 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.StructuralPartialEq.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 112100 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Sync.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 98155 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Unpin.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 15303 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.StructuralPartialEq.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 118700 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Sync.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 102115 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Unpin.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/num/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/num/nonzero/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/num/nonzero/trait.ZeroablePrimitive.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 1836 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.Add.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 1926 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.AddAssign.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 2067 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.Add.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 2157 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.AddAssign.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.Div.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.DivAssign.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.Mul.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.MulAssign.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.Neg.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.Rem.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.RemAssign.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 2937 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.Sub.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 3069 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.Sub.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 882 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.SubAssign.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/async_function/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 963 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/async_function/trait.AsyncFn.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 981 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/async_function/trait.AsyncFnMut.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 987 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/async_function/trait.AsyncFnOnce.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 1095 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/async_function/trait.AsyncFn.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 1113 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/async_function/trait.AsyncFnMut.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 1119 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/async_function/trait.AsyncFnOnce.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 2086 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitAnd.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 2218 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitAnd.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitAndAssign.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 2080 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitOr.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 2212 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitOr.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitOrAssign.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 2086 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitXor.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 2218 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitXor.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitXorAssign.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.Not.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.Shl.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.ShlAssign.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.Shr.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.ShrAssign.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/coroutine/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 1739 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/coroutine/trait.Coroutine.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 2003 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/coroutine/trait.Coroutine.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/deref/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 8124 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/deref/trait.Deref.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 4626 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/deref/trait.DerefMut.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 8652 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/deref/trait.Deref.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 4923 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/deref/trait.DerefMut.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/drop/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 13782 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/drop/trait.Drop.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 14937 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/drop/trait.Drop.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/function/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 909 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/function/trait.Fn.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 927 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/function/trait.FnMut.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 933 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/function/trait.FnOnce.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 1041 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/function/trait.Fn.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 1059 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/function/trait.FnMut.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 1065 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/function/trait.FnOnce.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/index/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 4602 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/index/trait.Index.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 2099 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/index/trait.IndexMut.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5064 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/index/trait.Index.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 2297 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/index/trait.IndexMut.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/range/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/range/trait.OneSidedRange.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/range/trait.RangeBounds.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/try_trait/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/try_trait/trait.FromResidual.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/try_trait/trait.Residual.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 190 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/try_trait/trait.Try.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/unsize/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 4365 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/unsize/trait.CoerceUnsized.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 3880 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/unsize/trait.DispatchFromDyn.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5025 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/unsize/trait.CoerceUnsized.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 4540 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/unsize/trait.DispatchFromDyn.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/panic/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/panic/unwind_safe/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 130297 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js │ │ │ │ --rw-r--r-- 0 root (0) root (0) 117548 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 136963 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 122894 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/slice/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/slice/index/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 202 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/slice/index/trait.SliceIndex.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 180 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/slice/trait.SlicePattern.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/str/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/str/pattern/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 202 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/core/str/pattern/trait.DoubleEndedSearcher.js │ │ │ │ @@ -35913,20 +35913,20 @@ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/test/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/test/stats/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 180 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/trait.impl/test/stats/trait.Stats.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1484 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/tutorial.html │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/alloc/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/alloc/alloc/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 13380 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/alloc/alloc/struct.LayoutError.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 14997 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/alloc/alloc/struct.LayoutError.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/alloc/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 13065 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/alloc/struct.LayoutError.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/convert/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 26702 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/convert/enum.Infallible.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 31124 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/convert/enum.Infallible.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/num/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 463446 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/num/struct.NonZero.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 154369 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/primitive.f32.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 160207 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/primitive.f64.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 536785 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/primitive.i16.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 565245 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/primitive.i32.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 540023 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/primitive.i64.js │ │ │ │ @@ -35934,15 +35934,15 @@ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 547788 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/primitive.isize.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 525066 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/primitive.u16.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 524335 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/primitive.u32.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 525906 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/primitive.u64.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 568295 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/primitive.u8.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 526632 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/primitive.usize.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/result/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 280119 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/result/enum.Result.js │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 294012 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/result/enum.Result.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/simd/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 214279 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/simd/struct.Mask.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1733791 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/core/simd/struct.Simd.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/std/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/std/alloc/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 13252 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/std/alloc/struct.LayoutError.js │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-08-28 14:44:23.000000 ./usr/share/doc/rust-web-doc/html/type.impl/std/convert/ │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.alloc.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ alloc in alloc::alloc - Rust
│ │ │ │ -

Function alloc::alloc::alloc

1.28.0 · source · 
pub unsafe fn alloc(layout: Layout) -> *mut u8
Expand description

Allocate memory with the global allocator.

│ │ │ │ +

Function alloc::alloc::alloc

1.28.0 · source · 
pub unsafe fn alloc(layout: Layout) -> *mut u8
Expand description

Allocate memory with the global allocator.

│ │ │ │

This function forwards calls to the GlobalAlloc::alloc method │ │ │ │ of the allocator registered with the #[global_allocator] attribute │ │ │ │ if there is one, or the std crate’s default.

│ │ │ │

This function is expected to be deprecated in favor of the alloc method │ │ │ │ of the Global type when it and the Allocator trait become stable.

│ │ │ │

§Safety

│ │ │ │

See GlobalAlloc::alloc.

│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.alloc_zeroed.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ alloc_zeroed in alloc::alloc - Rust
│ │ │ │ -

Function alloc::alloc::alloc_zeroed

1.28.0 · source · 
pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8
Expand description

Allocate zero-initialized memory with the global allocator.

│ │ │ │ +

Function alloc::alloc::alloc_zeroed

1.28.0 · source · 
pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8
Expand description

Allocate zero-initialized memory with the global allocator.

│ │ │ │

This function forwards calls to the GlobalAlloc::alloc_zeroed method │ │ │ │ of the allocator registered with the #[global_allocator] attribute │ │ │ │ if there is one, or the std crate’s default.

│ │ │ │

This function is expected to be deprecated in favor of the alloc_zeroed method │ │ │ │ of the Global type when it and the Allocator trait become stable.

│ │ │ │

§Safety

│ │ │ │

See GlobalAlloc::alloc_zeroed.

│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.dealloc.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ dealloc in alloc::alloc - Rust
│ │ │ │ -

Function alloc::alloc::dealloc

1.28.0 · source · 
pub unsafe fn dealloc(ptr: *mut u8, layout: Layout)
Expand description

Deallocate memory with the global allocator.

│ │ │ │ +

Function alloc::alloc::dealloc

1.28.0 · source · 
pub unsafe fn dealloc(ptr: *mut u8, layout: Layout)
Expand description

Deallocate memory with the global allocator.

│ │ │ │

This function forwards calls to the GlobalAlloc::dealloc method │ │ │ │ of the allocator registered with the #[global_allocator] attribute │ │ │ │ if there is one, or the std crate’s default.

│ │ │ │

This function is expected to be deprecated in favor of the dealloc method │ │ │ │ of the Global type when it and the Allocator trait become stable.

│ │ │ │

§Safety

│ │ │ │

See GlobalAlloc::dealloc.

│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.handle_alloc_error.html │ │ │ │ @@ -1,23 +1,23 @@ │ │ │ │ handle_alloc_error in alloc::alloc - Rust
│ │ │ │ -

Function alloc::alloc::handle_alloc_error

1.28.0 (const: unstable) · source · 
pub fn handle_alloc_error(layout: Layout) -> !
Expand description

Signal a memory allocation error.

│ │ │ │ +

Function alloc::alloc::handle_alloc_error

1.28.0 (const: unstable) · source · 
pub fn handle_alloc_error(layout: Layout) -> !
Expand description

Signal a memory allocation error.

│ │ │ │

Callers of memory allocation APIs wishing to cease execution │ │ │ │ in response to an allocation error are encouraged to call this function, │ │ │ │ -rather than directly invoking panic! or similar.

│ │ │ │ +rather than directly invoking panic! or similar.

│ │ │ │

This function is guaranteed to diverge (not return normally with a value), but depending on │ │ │ │ global configuration, it may either panic (resulting in unwinding or aborting as per │ │ │ │ configuration for all panics), or abort the process (with no unwinding).

│ │ │ │

The default behavior is:

│ │ │ │
    │ │ │ │
  • │ │ │ │

    If the binary links against std (typically the case), then │ │ │ │ print a message to standard error and abort the process. │ │ │ │ This behavior can be replaced with set_alloc_error_hook and take_alloc_error_hook. │ │ │ │ Future versions of Rust may panic by default instead.

    │ │ │ │
    • │ │ │ │
  • │ │ │ │

    If the binary does not link against std (all of its crates are marked │ │ │ │ -#![no_std]), then call panic! with a message. │ │ │ │ +#![no_std]), then call panic! with a message. │ │ │ │ The panic handler applies as to any panic.

    │ │ │ │
    • │ │ │ │
│ │ │ │
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/fn.realloc.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ realloc in alloc::alloc - Rust
│ │ │ │ -

Function alloc::alloc::realloc

1.28.0 · source · 
pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8
Expand description

Reallocate memory with the global allocator.

│ │ │ │ +

Function alloc::alloc::realloc

1.28.0 · source · 
pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8
Expand description

Reallocate memory with the global allocator.

│ │ │ │

This function forwards calls to the GlobalAlloc::realloc method │ │ │ │ of the allocator registered with the #[global_allocator] attribute │ │ │ │ if there is one, or the std crate’s default.

│ │ │ │

This function is expected to be deprecated in favor of the realloc method │ │ │ │ of the Global type when it and the Allocator trait become stable.

│ │ │ │

§Safety

│ │ │ │

See GlobalAlloc::realloc.

│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.AllocError.html │ │ │ │ @@ -1,20 +1,20 @@ │ │ │ │ AllocError in alloc::alloc - Rust
│ │ │ │ -

Struct alloc::alloc::AllocError

source · 
pub struct AllocError;
🔬This is a nightly-only experimental API. (allocator_api #32838)
Expand description

The AllocError error indicates an allocation failure │ │ │ │ +

Struct alloc::alloc::AllocError

source · 
pub struct AllocError;
🔬This is a nightly-only experimental API. (allocator_api #32838)
Expand description

The AllocError error indicates an allocation failure │ │ │ │ that may be due to resource exhaustion or to │ │ │ │ something wrong when combining the given input arguments with this │ │ │ │ allocator.

│ │ │ │ -

Trait Implementations§

source§

impl Clone for AllocError

source§

fn clone(&self) -> AllocError

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for AllocError

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

impl Display for AllocError

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

impl Error for AllocError

1.30.0 · source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
Provides type based access to context intended for error reports. Read more
source§

impl PartialEq for AllocError

source§

fn eq(&self, other: &AllocError) -> bool

This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
source§

impl Copy for AllocError

source§

impl Eq for AllocError

source§

impl StructuralPartialEq for AllocError

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where │ │ │ │ - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where │ │ │ │ - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where │ │ │ │ - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

│ │ │ │ -
source§

impl<T, U> Into<U> for T
where │ │ │ │ - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

│ │ │ │ +

Trait Implementations§

source§

impl Clone for AllocError

source§

fn clone(&self) -> AllocError

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for AllocError

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

impl Display for AllocError

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

impl Error for AllocError

1.30.0 · source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
Provides type based access to context intended for error reports. Read more
source§

impl PartialEq for AllocError

source§

fn eq(&self, other: &AllocError) -> bool

This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
source§

impl Copy for AllocError

source§

impl Eq for AllocError

source§

impl StructuralPartialEq for AllocError

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where │ │ │ │ + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where │ │ │ │ + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where │ │ │ │ + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

│ │ │ │ +
source§

impl<T, U> Into<U> for T
where │ │ │ │ + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

│ │ │ │

That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

│ │ │ │ +From<T> for U chooses to do.

│ │ │ │
source§

impl<T> ToOwned for T
where │ │ │ │ - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where │ │ │ │ - T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where │ │ │ │ - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where │ │ │ │ - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
│ │ │ │ + T: Clone,
§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where │ │ │ │ + T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where │ │ │ │ + U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where │ │ │ │ + U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.Global.html │ │ │ │ @@ -1,36 +1,36 @@ │ │ │ │ Global in alloc::alloc - Rust
│ │ │ │

Struct alloc::alloc::Global

source · 
pub struct Global;
🔬This is a nightly-only experimental API. (allocator_api #32838)
Expand description

The global memory allocator.

│ │ │ │

This type implements the Allocator trait by forwarding calls │ │ │ │ to the allocator registered with the #[global_allocator] attribute │ │ │ │ if there is one, or the std crate’s default.

│ │ │ │

Note: while this type is unstable, the functionality it provides can be │ │ │ │ accessed through the free functions in alloc.

│ │ │ │ -

Trait Implementations§

source§

impl Allocator for Global

source§

fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)
Attempts to allocate a block of memory. Read more
source§

fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)
Behaves like allocate, but also ensures that the returned memory is zero-initialized. Read more
source§

unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout)

🔬This is a nightly-only experimental API. (allocator_api #32838)
Deallocates the memory referenced by ptr. Read more
source§

unsafe fn grow( │ │ │ │ +

Trait Implementations§

source§

impl Allocator for Global

source§

fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)
Attempts to allocate a block of memory. Read more
source§

fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)
Behaves like allocate, but also ensures that the returned memory is zero-initialized. Read more
source§

unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout)

🔬This is a nightly-only experimental API. (allocator_api #32838)
Deallocates the memory referenced by ptr. Read more
source§

unsafe fn grow( │ │ │ │ &self, │ │ │ │ - ptr: NonNull<u8>, │ │ │ │ + ptr: NonNull<u8>, │ │ │ │ old_layout: Layout, │ │ │ │ new_layout: Layout │ │ │ │ -) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)
Attempts to extend the memory block. Read more
source§

unsafe fn grow_zeroed( │ │ │ │ +) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)
Attempts to extend the memory block. Read more
source§

unsafe fn grow_zeroed( │ │ │ │ &self, │ │ │ │ - ptr: NonNull<u8>, │ │ │ │ + ptr: NonNull<u8>, │ │ │ │ old_layout: Layout, │ │ │ │ new_layout: Layout │ │ │ │ -) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)
Behaves like grow, but also ensures that the new contents are set to zero before being │ │ │ │ +) -> Result<NonNull<[u8]>, AllocError>
🔬This is a nightly-only experimental API. (allocator_api #32838)
Behaves like grow, but also ensures that the new contents are set to zero before being │ │ │ │ returned. Read more
source§

unsafe fn shrink( │ │ │ │ &self, │ │ │ │ - ptr: NonNull<u8>, │ │ │ │ + ptr: NonNull<u8>, │ │ │ │ old_layout: Layout, │ │ │ │ new_layout: Layout │ │ │ │ -) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)
Attempts to shrink the memory block. Read more
source§

fn by_ref(&self) -> &Self
where │ │ │ │ - Self: Sized,

🔬This is a nightly-only experimental API. (allocator_api #32838)
Creates a “by reference” adapter for this instance of Allocator. Read more
source§

impl Clone for Global

source§

fn clone(&self) -> Global

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Global

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for Global

source§

fn default() -> Global

Returns the “default value” for a type. Read more
source§

impl Copy for Global

source§

impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Box<U>> for Box<T, Global>

Auto Trait Implementations§

§

impl Freeze for Global

§

impl RefUnwindSafe for Global

§

impl Send for Global

§

impl Sync for Global

§

impl Unpin for Global

§

impl UnwindSafe for Global

Blanket Implementations§

source§

impl<T> Any for T
where │ │ │ │ - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where │ │ │ │ - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where │ │ │ │ - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

│ │ │ │ -
source§

impl<T, U> Into<U> for T
where │ │ │ │ - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

│ │ │ │ +) -> Result<NonNull<[u8]>, AllocError>
🔬This is a nightly-only experimental API. (allocator_api #32838)
Attempts to shrink the memory block. Read more
source§

fn by_ref(&self) -> &Self
where │ │ │ │ + Self: Sized,

🔬This is a nightly-only experimental API. (allocator_api #32838)
Creates a “by reference” adapter for this instance of Allocator. Read more
source§

impl Clone for Global

source§

fn clone(&self) -> Global

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Global

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for Global

source§

fn default() -> Global

Returns the “default value” for a type. Read more
source§

impl Copy for Global

source§

impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Box<U>> for Box<T, Global>

Auto Trait Implementations§

§

impl Freeze for Global

§

impl RefUnwindSafe for Global

§

impl Send for Global

§

impl Sync for Global

§

impl Unpin for Global

§

impl UnwindSafe for Global

Blanket Implementations§

source§

impl<T> Any for T
where │ │ │ │ + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where │ │ │ │ + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where │ │ │ │ + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

│ │ │ │ +
source§

impl<T, U> Into<U> for T
where │ │ │ │ + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

│ │ │ │

That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

│ │ │ │ +From<T> for U chooses to do.

│ │ │ │
source§

impl<T> ToOwned for T
where │ │ │ │ - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where │ │ │ │ - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where │ │ │ │ - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
│ │ │ │ + T: Clone,
§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where │ │ │ │ + U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where │ │ │ │ + U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.Layout.html │ │ │ │ @@ -1,21 +1,21 @@ │ │ │ │ Layout in alloc::alloc - Rust
│ │ │ │ -

Struct alloc::alloc::Layout

1.28.0 · source · 
pub struct Layout { /* private fields */ }
Expand description

Layout of a block of memory.

│ │ │ │ +

Struct alloc::alloc::Layout

1.28.0 · source · 
pub struct Layout { /* private fields */ }
Expand description

Layout of a block of memory.

│ │ │ │

An instance of Layout describes a particular layout of memory. │ │ │ │ You build a Layout up as an input to give to an allocator.

│ │ │ │

All layouts have an associated size and a power-of-two alignment.

│ │ │ │

(Note that layouts are not required to have non-zero size, │ │ │ │ even though GlobalAlloc requires that all memory requests │ │ │ │ be non-zero in size. A caller must either ensure that conditions │ │ │ │ like this are met, use specific allocators with looser │ │ │ │ requirements, or use the more lenient Allocator interface.)

│ │ │ │ -

Implementations§

source§

impl Layout

const: 1.50.0 · source

pub const fn from_size_align( │ │ │ │ - size: usize, │ │ │ │ - align: usize │ │ │ │ -) -> Result<Layout, LayoutError>

Constructs a Layout from a given size and align, │ │ │ │ +

Implementations§

source§

impl Layout

const: 1.50.0 · source

pub const fn from_size_align( │ │ │ │ + size: usize, │ │ │ │ + align: usize │ │ │ │ +) -> Result<Layout, LayoutError>

Constructs a Layout from a given size and align, │ │ │ │ or returns LayoutError if any of the following conditions │ │ │ │ are not met:

│ │ │ │
    │ │ │ │
  • │ │ │ │

    align must not be zero,

    │ │ │ │
    • │ │ │ │
  • │ │ │ │ @@ -23,95 +23,95 @@ │ │ │ │
    • │ │ │ │
  • │ │ │ │

    size, when rounded up to the nearest multiple of align, │ │ │ │ must not overflow isize (i.e., the rounded value must be │ │ │ │ less than or equal to isize::MAX).

    │ │ │ │
    • │ │ │ │
│ │ │ │ -
const: 1.36.0 · source

pub const unsafe fn from_size_align_unchecked( │ │ │ │ - size: usize, │ │ │ │ - align: usize │ │ │ │ +

const: 1.36.0 · source

pub const unsafe fn from_size_align_unchecked( │ │ │ │ + size: usize, │ │ │ │ + align: usize │ │ │ │ ) -> Layout

Creates a layout, bypassing all checks.

│ │ │ │
§Safety
│ │ │ │

This function is unsafe as it does not verify the preconditions from │ │ │ │ Layout::from_size_align.

│ │ │ │ -
const: 1.50.0 · source

pub const fn size(&self) -> usize

The minimum size in bytes for a memory block of this layout.

│ │ │ │ -
const: 1.50.0 · source

pub const fn align(&self) -> usize

The minimum byte alignment for a memory block of this layout.

│ │ │ │ +
const: 1.50.0 · source

pub const fn size(&self) -> usize

The minimum size in bytes for a memory block of this layout.

│ │ │ │ +
const: 1.50.0 · source

pub const fn align(&self) -> usize

The minimum byte alignment for a memory block of this layout.

│ │ │ │

The returned alignment is guaranteed to be a power of two.

│ │ │ │ -
const: 1.42.0 · source

pub const fn new<T>() -> Layout

Constructs a Layout suitable for holding a value of type T.

│ │ │ │ -
const: unstable · source

pub fn for_value<T>(t: &T) -> Layout
where │ │ │ │ - T: ?Sized,

Produces layout describing a record that could be used to │ │ │ │ +

const: 1.42.0 · source

pub const fn new<T>() -> Layout

Constructs a Layout suitable for holding a value of type T.

│ │ │ │ +
const: unstable · source

pub fn for_value<T>(t: &T) -> Layout
where │ │ │ │ + T: ?Sized,

Produces layout describing a record that could be used to │ │ │ │ allocate backing structure for T (which could be a trait │ │ │ │ or other unsized type like a slice).

│ │ │ │ -
const: unstable · source

pub unsafe fn for_value_raw<T>(t: *const T) -> Layout
where │ │ │ │ - T: ?Sized,

🔬This is a nightly-only experimental API. (layout_for_ptr #69835)

Produces layout describing a record that could be used to │ │ │ │ +

const: unstable · source

pub unsafe fn for_value_raw<T>(t: *const T) -> Layout
where │ │ │ │ + T: ?Sized,

🔬This is a nightly-only experimental API. (layout_for_ptr #69835)

Produces layout describing a record that could be used to │ │ │ │ allocate backing structure for T (which could be a trait │ │ │ │ or other unsized type like a slice).

│ │ │ │
§Safety
│ │ │ │

This function is only safe to call if the following conditions hold:

│ │ │ │
    │ │ │ │
  • If T is Sized, this function is always safe to call.
    • │ │ │ │
  • If the unsized tail of T is: │ │ │ │
      │ │ │ │ -
    • a slice, then the length of the slice tail must be an initialized │ │ │ │ +
    • a slice, then the length of the slice tail must be an initialized │ │ │ │ integer, and the size of the entire value │ │ │ │ (dynamic tail length + statically sized prefix) must fit in isize.
      • │ │ │ │
    • a trait object, then the vtable part of the pointer must point │ │ │ │ to a valid vtable for the type T acquired by an unsizing coercion, │ │ │ │ and the size of the entire value │ │ │ │ (dynamic tail length + statically sized prefix) must fit in isize.
      • │ │ │ │
    • an (unstable) extern type, then this function is always safe to │ │ │ │ call, but may panic or otherwise return the wrong value, as the │ │ │ │ extern type’s layout is not known. This is the same behavior as │ │ │ │ Layout::for_value on a reference to an extern type tail.
      • │ │ │ │
    • otherwise, it is conservatively not allowed to call this function.
      • │ │ │ │
    │ │ │ │
    • │ │ │ │
│ │ │ │ -
const: unstable · source

pub fn dangling(&self) -> NonNull<u8>

🔬This is a nightly-only experimental API. (alloc_layout_extra #55724)

Creates a NonNull that is dangling, but well-aligned for this Layout.

│ │ │ │ +
const: unstable · source

pub fn dangling(&self) -> NonNull<u8>

🔬This is a nightly-only experimental API. (alloc_layout_extra #55724)

Creates a NonNull that is dangling, but well-aligned for this Layout.

│ │ │ │

Note that the pointer value may potentially represent a valid pointer, │ │ │ │ which means this must not be used as a “not yet initialized” │ │ │ │ sentinel value. Types that lazily allocate must track initialization by │ │ │ │ some other means.

│ │ │ │ -
1.44.0 · source

pub fn align_to(&self, align: usize) -> Result<Layout, LayoutError>

Creates a layout describing the record that can hold a value │ │ │ │ +

1.44.0 · source

pub fn align_to(&self, align: usize) -> Result<Layout, LayoutError>

Creates a layout describing the record that can hold a value │ │ │ │ of the same layout as self, but that also is aligned to │ │ │ │ alignment align (measured in bytes).

│ │ │ │

If self already meets the prescribed alignment, then returns │ │ │ │ self.

│ │ │ │

Note that this method does not add any padding to the overall │ │ │ │ size, regardless of whether the returned layout has a different │ │ │ │ alignment. In other words, if K has size 16, K.align_to(32) │ │ │ │ will still have size 16.

│ │ │ │

Returns an error if the combination of self.size() and the given │ │ │ │ align violates the conditions listed in Layout::from_size_align.

│ │ │ │ -
const: unstable · source

pub fn padding_needed_for(&self, align: usize) -> usize

🔬This is a nightly-only experimental API. (alloc_layout_extra #55724)

Returns the amount of padding we must insert after self │ │ │ │ +

const: unstable · source

pub fn padding_needed_for(&self, align: usize) -> usize

🔬This is a nightly-only experimental API. (alloc_layout_extra #55724)

Returns the amount of padding we must insert after self │ │ │ │ to ensure that the following address will satisfy align │ │ │ │ (measured in bytes).

│ │ │ │

e.g., if self.size() is 9, then self.padding_needed_for(4) │ │ │ │ returns 3, because that is the minimum number of bytes of │ │ │ │ padding required to get a 4-aligned address (assuming that the │ │ │ │ corresponding memory block starts at a 4-aligned address).

│ │ │ │

The return value of this function has no meaning if align is │ │ │ │ not a power-of-two.

│ │ │ │

Note that the utility of the returned value requires align │ │ │ │ to be less than or equal to the alignment of the starting │ │ │ │ address for the whole allocated block of memory. One way to │ │ │ │ satisfy this constraint is to ensure align <= self.align().

│ │ │ │ -
1.44.0 (const: unstable) · source

pub fn pad_to_align(&self) -> Layout

Creates a layout by rounding the size of this layout up to a multiple │ │ │ │ +

1.44.0 (const: unstable) · source

pub fn pad_to_align(&self) -> Layout

Creates a layout by rounding the size of this layout up to a multiple │ │ │ │ of the layout’s alignment.

│ │ │ │

This is equivalent to adding the result of padding_needed_for │ │ │ │ to the layout’s current size.

│ │ │ │ -
source

pub fn repeat(&self, n: usize) -> Result<(Layout, usize), LayoutError>

🔬This is a nightly-only experimental API. (alloc_layout_extra #55724)

Creates a layout describing the record for n instances of │ │ │ │ +

source

pub fn repeat(&self, n: usize) -> Result<(Layout, usize), LayoutError>

🔬This is a nightly-only experimental API. (alloc_layout_extra #55724)

Creates a layout describing the record for n instances of │ │ │ │ self, with a suitable amount of padding between each to │ │ │ │ ensure that each instance is given its requested size and │ │ │ │ alignment. On success, returns (k, offs) where k is the │ │ │ │ layout of the array and offs is the distance between the start │ │ │ │ of each element in the array.

│ │ │ │

On arithmetic overflow, returns LayoutError.

│ │ │ │ -
1.44.0 · source

pub fn extend(&self, next: Layout) -> Result<(Layout, usize), LayoutError>

Creates a layout describing the record for self followed by │ │ │ │ +

1.44.0 · source

pub fn extend(&self, next: Layout) -> Result<(Layout, usize), LayoutError>

Creates a layout describing the record for self followed by │ │ │ │ next, including any necessary padding to ensure that next │ │ │ │ will be properly aligned, but no trailing padding.

│ │ │ │

In order to match C representation layout repr(C), you should │ │ │ │ call pad_to_align after extending the layout with all fields. │ │ │ │ (There is no way to match the default Rust representation │ │ │ │ layout repr(Rust), as it is unspecified.)

│ │ │ │

Note that the alignment of the resulting layout will be the maximum of │ │ │ │ @@ -132,42 +132,42 @@ │ │ │ │ let (new_layout, offset) = layout.extend(field)?; │ │ │ │ layout = new_layout; │ │ │ │ offsets.push(offset); │ │ │ │ } │ │ │ │ // Remember to finalize with `pad_to_align`! │ │ │ │ Ok((layout.pad_to_align(), offsets)) │ │ │ │ }Run

│ │ │ │ -
source

pub fn repeat_packed(&self, n: usize) -> Result<Layout, LayoutError>

🔬This is a nightly-only experimental API. (alloc_layout_extra #55724)

Creates a layout describing the record for n instances of │ │ │ │ +

source

pub fn repeat_packed(&self, n: usize) -> Result<Layout, LayoutError>

🔬This is a nightly-only experimental API. (alloc_layout_extra #55724)

Creates a layout describing the record for n instances of │ │ │ │ self, with no padding between each instance.

│ │ │ │

Note that, unlike repeat, repeat_packed does not guarantee │ │ │ │ that the repeated instances of self will be properly │ │ │ │ aligned, even if a given instance of self is properly │ │ │ │ aligned. In other words, if the layout returned by │ │ │ │ repeat_packed is used to allocate an array, it is not │ │ │ │ guaranteed that all elements in the array will be properly │ │ │ │ aligned.

│ │ │ │

On arithmetic overflow, returns LayoutError.

│ │ │ │ -
source

pub fn extend_packed(&self, next: Layout) -> Result<Layout, LayoutError>

🔬This is a nightly-only experimental API. (alloc_layout_extra #55724)

Creates a layout describing the record for self followed by │ │ │ │ +

source

pub fn extend_packed(&self, next: Layout) -> Result<Layout, LayoutError>

🔬This is a nightly-only experimental API. (alloc_layout_extra #55724)

Creates a layout describing the record for self followed by │ │ │ │ next with no additional padding between the two. Since no │ │ │ │ padding is inserted, the alignment of next is irrelevant, │ │ │ │ and is not incorporated at all into the resulting layout.

│ │ │ │

On arithmetic overflow, returns LayoutError.

│ │ │ │ -
1.44.0 (const: unstable) · source

pub fn array<T>(n: usize) -> Result<Layout, LayoutError>

Creates a layout describing the record for a [T; n].

│ │ │ │ +
1.44.0 (const: unstable) · source

pub fn array<T>(n: usize) -> Result<Layout, LayoutError>

Creates a layout describing the record for a [T; n].

│ │ │ │

On arithmetic overflow or when the total size would exceed │ │ │ │ isize::MAX, returns LayoutError.

│ │ │ │ -

Trait Implementations§

source§

impl Clone for Layout

source§

fn clone(&self) -> Layout

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Layout

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

impl Hash for Layout

source§

fn hash<__H>(&self, state: &mut __H)
where │ │ │ │ - __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where │ │ │ │ - H: Hasher, │ │ │ │ - Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl PartialEq for Layout

source§

fn eq(&self, other: &Layout) -> bool

This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
source§

impl Copy for Layout

source§

impl Eq for Layout

source§

impl StructuralPartialEq for Layout

Auto Trait Implementations§

§

impl Freeze for Layout

§

impl RefUnwindSafe for Layout

§

impl Send for Layout

§

impl Sync for Layout

§

impl Unpin for Layout

§

impl UnwindSafe for Layout

Blanket Implementations§

source§

impl<T> Any for T
where │ │ │ │ - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where │ │ │ │ - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where │ │ │ │ - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

│ │ │ │ -
source§

impl<T, U> Into<U> for T
where │ │ │ │ - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

│ │ │ │ +

Trait Implementations§

source§

impl Clone for Layout

source§

fn clone(&self) -> Layout

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Layout

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

impl Hash for Layout

source§

fn hash<__H>(&self, state: &mut __H)
where │ │ │ │ + __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where │ │ │ │ + H: Hasher, │ │ │ │ + Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl PartialEq for Layout

source§

fn eq(&self, other: &Layout) -> bool

This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
source§

impl Copy for Layout

source§

impl Eq for Layout

source§

impl StructuralPartialEq for Layout

Auto Trait Implementations§

§

impl Freeze for Layout

§

impl RefUnwindSafe for Layout

§

impl Send for Layout

§

impl Sync for Layout

§

impl Unpin for Layout

§

impl UnwindSafe for Layout

Blanket Implementations§

source§

impl<T> Any for T
where │ │ │ │ + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where │ │ │ │ + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where │ │ │ │ + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

│ │ │ │ +
source§

impl<T, U> Into<U> for T
where │ │ │ │ + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

│ │ │ │

That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

│ │ │ │ +From<T> for U chooses to do.

│ │ │ │
source§

impl<T> ToOwned for T
where │ │ │ │ - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where │ │ │ │ - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where │ │ │ │ - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
│ │ │ │ + T: Clone,
§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where │ │ │ │ + U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where │ │ │ │ + U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/struct.LayoutError.html │ │ │ │ @@ -1,20 +1,20 @@ │ │ │ │ LayoutError in alloc::alloc - Rust
│ │ │ │ -

Struct alloc::alloc::LayoutError

1.50.0 · source · 
#[non_exhaustive]
pub struct LayoutError;
Expand description

The parameters given to Layout::from_size_align │ │ │ │ +

Struct alloc::alloc::LayoutError

1.50.0 · source · 
#[non_exhaustive]
pub struct LayoutError;
Expand description

The parameters given to Layout::from_size_align │ │ │ │ or some other Layout constructor │ │ │ │ do not satisfy its documented constraints.

│ │ │ │ -

Trait Implementations§

source§

impl Clone for LayoutError

source§

fn clone(&self) -> LayoutError

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for LayoutError

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
1.28.0 · source§

impl Display for LayoutError

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
1.28.0 · source§

impl Error for LayoutError

1.30.0 · source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
Provides type based access to context intended for error reports. Read more
source§

impl From<LayoutError> for TryReserveErrorKind

source§

fn from(_: LayoutError) -> Self

Always evaluates to TryReserveErrorKind::CapacityOverflow.

│ │ │ │ -
source§

impl PartialEq for LayoutError

source§

fn eq(&self, other: &LayoutError) -> bool

This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
source§

impl Eq for LayoutError

source§

impl StructuralPartialEq for LayoutError

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where │ │ │ │ - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where │ │ │ │ - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where │ │ │ │ - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

│ │ │ │ -
source§

impl<T, U> Into<U> for T
where │ │ │ │ - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

│ │ │ │ +

Trait Implementations§

source§

impl Clone for LayoutError

source§

fn clone(&self) -> LayoutError

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for LayoutError

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
1.28.0 · source§

impl Display for LayoutError

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
1.28.0 · source§

impl Error for LayoutError

1.30.0 · source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
Provides type based access to context intended for error reports. Read more
source§

impl From<LayoutError> for TryReserveErrorKind

source§

fn from(_: LayoutError) -> Self

Always evaluates to TryReserveErrorKind::CapacityOverflow.

│ │ │ │ +
source§

impl PartialEq for LayoutError

source§

fn eq(&self, other: &LayoutError) -> bool

This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
source§

impl Eq for LayoutError

source§

impl StructuralPartialEq for LayoutError

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where │ │ │ │ + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where │ │ │ │ + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where │ │ │ │ + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

│ │ │ │ +
source§

impl<T, U> Into<U> for T
where │ │ │ │ + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

│ │ │ │

That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

│ │ │ │ +From<T> for U chooses to do.

│ │ │ │
source§

impl<T> ToOwned for T
where │ │ │ │ - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where │ │ │ │ - T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where │ │ │ │ - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where │ │ │ │ - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
│ │ │ │ + T: Clone,
§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where │ │ │ │ + T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where │ │ │ │ + U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where │ │ │ │ + U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/trait.Allocator.html │ │ │ │ @@ -1,38 +1,38 @@ │ │ │ │ Allocator in alloc::alloc - Rust
│ │ │ │ -

Trait alloc::alloc::Allocator

source · 
pub unsafe trait Allocator {
│ │ │ │ +    
Trait alloc::alloc::Allocator
source · 
pub unsafe trait Allocator {
│ │ │ │      // Required methods
│ │ │ │ -    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>;
│ │ │ │ -    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout);
│ │ │ │ +    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>;
│ │ │ │ +    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout);
│ │ │ │  
│ │ │ │      // Provided methods
│ │ │ │      fn allocate_zeroed(
│ │ │ │          &self,
│ │ │ │          layout: Layout
│ │ │ │ -    ) -> Result<NonNull<[u8]>, AllocError> { ... }
│ │ │ │ +    ) -> Result<NonNull<[u8]>, AllocError> { ... }
│ │ │ │      unsafe fn grow(
│ │ │ │          &self,
│ │ │ │ -        ptr: NonNull<u8>,
│ │ │ │ +        ptr: NonNull<u8>,
│ │ │ │          old_layout: Layout,
│ │ │ │          new_layout: Layout
│ │ │ │ -    ) -> Result<NonNull<[u8]>, AllocError> { ... }
│ │ │ │ +    ) -> Result<NonNull<[u8]>, AllocError> { ... }
│ │ │ │      unsafe fn grow_zeroed(
│ │ │ │          &self,
│ │ │ │ -        ptr: NonNull<u8>,
│ │ │ │ +        ptr: NonNull<u8>,
│ │ │ │          old_layout: Layout,
│ │ │ │          new_layout: Layout
│ │ │ │ -    ) -> Result<NonNull<[u8]>, AllocError> { ... }
│ │ │ │ +    ) -> Result<NonNull<[u8]>, AllocError> { ... }
│ │ │ │      unsafe fn shrink(
│ │ │ │          &self,
│ │ │ │ -        ptr: NonNull<u8>,
│ │ │ │ +        ptr: NonNull<u8>,
│ │ │ │          old_layout: Layout,
│ │ │ │          new_layout: Layout
│ │ │ │ -    ) -> Result<NonNull<[u8]>, AllocError> { ... }
│ │ │ │ -    fn by_ref(&self) -> &Self
│ │ │ │ -       where Self: Sized { ... }
│ │ │ │ +    ) -> Result<NonNull<[u8]>, AllocError> { ... }
│ │ │ │ +    fn by_ref(&self) -> &Self
│ │ │ │ +       where Self: Sized { ... }
│ │ │ │  }
🔬This is a nightly-only experimental API. (allocator_api #32838)
Expand description
An implementation of Allocator can allocate, grow, shrink, and deallocate arbitrary blocks of
│ │ │ │  data described via Layout.

│ │ │ │  
Allocator is designed to be implemented on ZSTs, references, or smart pointers because having
│ │ │ │  an allocator like MyAlloc([u8; N]) cannot be moved, without updating the pointers to the
│ │ │ │  allocated memory.

│ │ │ │  
Unlike GlobalAlloc, zero-sized allocations are allowed in Allocator. If an underlying
│ │ │ │  allocator does not support this (like jemalloc) or return a null pointer (such as
│ │ │ │ @@ -84,16 +84,16 @@
│ │ │ │  allocator. A copied or cloned allocator must behave like the same allocator, and

│ │ │ │  
│ │ │ │  
  • 
│ │ │ │  
    any pointer to a memory block which is currently allocated may be passed to any other
│ │ │ │  method of the allocator.
    
│ │ │ │  
    • 
│ │ │ │  
│ │ │ │ -
    Required Methods§
    source
    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Attempts to allocate a block of memory.
    
│ │ │ │ -
    On success, returns a NonNull<[u8]> meeting the size and alignment guarantees of layout.
    
│ │ │ │ +
    Required Methods§
    source
    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Attempts to allocate a block of memory.
    
│ │ │ │ +
    On success, returns a NonNull<[u8]> meeting the size and alignment guarantees of layout.
    
│ │ │ │  
    The returned block may have a larger size than specified by layout.size(), and may or may
│ │ │ │  not have its contents initialized.
    
│ │ │ │  
    The returned block of memory remains valid as long as it is [currently allocated] and the shorter of:
    
│ │ │ │  
      
│ │ │ │  
    • the borrow-checker lifetime of the allocator type itself.
      • 
│ │ │ │  
    • as long as at the allocator and all its clones has not been dropped.
      • 
│ │ │ │  
    
│ │ │ │ @@ -101,36 +101,36 @@
│ │ │ │  
    Returning Err indicates that either memory is exhausted or layout does not meet
│ │ │ │  allocator’s size or alignment constraints.
    
│ │ │ │  
    Implementations are encouraged to return Err on memory exhaustion rather than panicking or
│ │ │ │  aborting, but this is not a strict requirement. (Specifically: it is legal to implement
│ │ │ │  this trait atop an underlying native allocation library that aborts on memory exhaustion.)
    
│ │ │ │  
    Clients wishing to abort computation in response to an allocation error are encouraged to
│ │ │ │  call the handle_alloc_error function, rather than directly invoking panic! or similar.
    
│ │ │ │ -
    source
    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout)
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Deallocates the memory referenced by ptr.
    
│ │ │ │ +
    source
    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout)
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Deallocates the memory referenced by ptr.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
      
│ │ │ │  
    • ptr must denote a block of memory currently allocated via this allocator, and
      • 
│ │ │ │  
    • layout must fit that block of memory.
      • 
│ │ │ │  
    
│ │ │ │ -
    Provided Methods§
    source
    fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Behaves like allocate, but also ensures that the returned memory is zero-initialized.
    
│ │ │ │ +
    Provided Methods§
    source
    fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Behaves like allocate, but also ensures that the returned memory is zero-initialized.
    
│ │ │ │  
    §Errors
    
│ │ │ │  
    Returning Err indicates that either memory is exhausted or layout does not meet
│ │ │ │  allocator’s size or alignment constraints.
    
│ │ │ │  
    Implementations are encouraged to return Err on memory exhaustion rather than panicking or
│ │ │ │  aborting, but this is not a strict requirement. (Specifically: it is legal to implement
│ │ │ │  this trait atop an underlying native allocation library that aborts on memory exhaustion.)
    
│ │ │ │  
    Clients wishing to abort computation in response to an allocation error are encouraged to
│ │ │ │  call the handle_alloc_error function, rather than directly invoking panic! or similar.
    
│ │ │ │ -
    source
    unsafe fn grow(
│ │ │ │ +
    source
    unsafe fn grow(
│ │ │ │      &self,
│ │ │ │ -    ptr: NonNull<u8>,
│ │ │ │ +    ptr: NonNull<u8>,
│ │ │ │      old_layout: Layout,
│ │ │ │      new_layout: Layout
│ │ │ │ -) -> Result<NonNull<[u8]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Attempts to extend the memory block.
    
│ │ │ │ -
    Returns a new NonNull<[u8]> containing a pointer and the actual size of the allocated
│ │ │ │ +) -> Result<NonNull<[u8]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Attempts to extend the memory block.
    
│ │ │ │ +
    Returns a new NonNull<[u8]> containing a pointer and the actual size of the allocated
│ │ │ │  memory. The pointer is suitable for holding data described by new_layout. To accomplish
│ │ │ │  this, the allocator may extend the allocation referenced by ptr to fit the new layout.
    
│ │ │ │  
    If this returns Ok, then ownership of the memory block referenced by ptr has been
│ │ │ │  transferred to this allocator. Any access to the old ptr is Undefined Behavior, even if the
│ │ │ │  allocation was grown in-place. The newly returned pointer is the only valid pointer
│ │ │ │  for accessing this memory now.
    
│ │ │ │  
    If this method returns Err, then ownership of the memory block has not been transferred to
│ │ │ │ @@ -146,20 +146,20 @@
│ │ │ │  
    Returns Err if the new layout does not meet the allocator’s size and alignment
│ │ │ │  constraints of the allocator, or if growing otherwise fails.
    
│ │ │ │  
    Implementations are encouraged to return Err on memory exhaustion rather than panicking or
│ │ │ │  aborting, but this is not a strict requirement. (Specifically: it is legal to implement
│ │ │ │  this trait atop an underlying native allocation library that aborts on memory exhaustion.)
    
│ │ │ │  
    Clients wishing to abort computation in response to an allocation error are encouraged to
│ │ │ │  call the handle_alloc_error function, rather than directly invoking panic! or similar.
    
│ │ │ │ -
    source
    unsafe fn grow_zeroed(
│ │ │ │ +
    source
    unsafe fn grow_zeroed(
│ │ │ │      &self,
│ │ │ │ -    ptr: NonNull<u8>,
│ │ │ │ +    ptr: NonNull<u8>,
│ │ │ │      old_layout: Layout,
│ │ │ │      new_layout: Layout
│ │ │ │ -) -> Result<NonNull<[u8]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Behaves like grow, but also ensures that the new contents are set to zero before being
│ │ │ │ +) -> Result<NonNull<[u8]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Behaves like grow, but also ensures that the new contents are set to zero before being │ │ │ │ returned.

    │ │ │ │

    The memory block will contain the following contents after a successful call to │ │ │ │ grow_zeroed:

    │ │ │ │
      │ │ │ │
    • Bytes 0..old_layout.size() are preserved from the original allocation.
      • │ │ │ │
    • Bytes old_layout.size()..old_size will either be preserved or zeroed, depending on │ │ │ │ the allocator implementation. old_size refers to the size of the memory block prior │ │ │ │ @@ -179,21 +179,21 @@ │ │ │ │

      Returns Err if the new layout does not meet the allocator’s size and alignment │ │ │ │ constraints of the allocator, or if growing otherwise fails.

      │ │ │ │

      Implementations are encouraged to return Err on memory exhaustion rather than panicking or │ │ │ │ aborting, but this is not a strict requirement. (Specifically: it is legal to implement │ │ │ │ this trait atop an underlying native allocation library that aborts on memory exhaustion.)

      │ │ │ │

      Clients wishing to abort computation in response to an allocation error are encouraged to │ │ │ │ call the handle_alloc_error function, rather than directly invoking panic! or similar.

      │ │ │ │ -
    source

    unsafe fn shrink( │ │ │ │ +

    source

    unsafe fn shrink( │ │ │ │ &self, │ │ │ │ - ptr: NonNull<u8>, │ │ │ │ + ptr: NonNull<u8>, │ │ │ │ old_layout: Layout, │ │ │ │ new_layout: Layout │ │ │ │ -) -> Result<NonNull<[u8]>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Attempts to shrink the memory block.

    │ │ │ │ -

    Returns a new NonNull<[u8]> containing a pointer and the actual size of the allocated │ │ │ │ +) -> Result<NonNull<[u8]>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Attempts to shrink the memory block.

    │ │ │ │ +

    Returns a new NonNull<[u8]> containing a pointer and the actual size of the allocated │ │ │ │ memory. The pointer is suitable for holding data described by new_layout. To accomplish │ │ │ │ this, the allocator may shrink the allocation referenced by ptr to fit the new layout.

    │ │ │ │

    If this returns Ok, then ownership of the memory block referenced by ptr has been │ │ │ │ transferred to this allocator. Any access to the old ptr is Undefined Behavior, even if the │ │ │ │ allocation was shrunk in-place. The newly returned pointer is the only valid pointer │ │ │ │ for accessing this memory now.

    │ │ │ │

    If this method returns Err, then ownership of the memory block has not been transferred to │ │ │ │ @@ -209,12 +209,12 @@ │ │ │ │

    Returns Err if the new layout does not meet the allocator’s size and alignment │ │ │ │ constraints of the allocator, or if shrinking otherwise fails.

    │ │ │ │

    Implementations are encouraged to return Err on memory exhaustion rather than panicking or │ │ │ │ aborting, but this is not a strict requirement. (Specifically: it is legal to implement │ │ │ │ this trait atop an underlying native allocation library that aborts on memory exhaustion.)

    │ │ │ │

    Clients wishing to abort computation in response to an allocation error are encouraged to │ │ │ │ call the handle_alloc_error function, rather than directly invoking panic! or similar.

    │ │ │ │ -
    source

    fn by_ref(&self) -> &Self
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Creates a “by reference” adapter for this instance of Allocator.

    │ │ │ │ +
    source

    fn by_ref(&self) -> &Self
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Creates a “by reference” adapter for this instance of Allocator.

    │ │ │ │

    The returned adapter also implements Allocator and will simply borrow this.

    │ │ │ │ -

    Implementors§

    source§

    impl Allocator for Global

    source§

    impl<A> Allocator for &A
    where │ │ │ │ - A: Allocator + ?Sized,

    │ │ │ │ +

    Implementors§

    source§

    impl Allocator for Global

    source§

    impl<A> Allocator for &A
    where │ │ │ │ + A: Allocator + ?Sized,

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/trait.GlobalAlloc.html │ │ │ │ @@ -1,21 +1,21 @@ │ │ │ │ GlobalAlloc in alloc::alloc - Rust
    │ │ │ │ -

    Trait alloc::alloc::GlobalAlloc

    1.28.0 · source · 
    pub unsafe trait GlobalAlloc {
│ │ │ │ +    
    Trait alloc::alloc::GlobalAlloc
    1.28.0 · source · 
    pub unsafe trait GlobalAlloc {
│ │ │ │      // Required methods
│ │ │ │ -    unsafe fn alloc(&self, layout: Layout) -> *mut u8;
│ │ │ │ -    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout);
│ │ │ │ +    unsafe fn alloc(&self, layout: Layout) -> *mut u8;
│ │ │ │ +    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout);
│ │ │ │  
│ │ │ │      // Provided methods
│ │ │ │ -    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 { ... }
│ │ │ │ +    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 { ... }
│ │ │ │      unsafe fn realloc(
│ │ │ │          &self,
│ │ │ │ -        ptr: *mut u8,
│ │ │ │ +        ptr: *mut u8,
│ │ │ │          layout: Layout,
│ │ │ │ -        new_size: usize
│ │ │ │ -    ) -> *mut u8 { ... }
│ │ │ │ +        new_size: usize
│ │ │ │ +    ) -> *mut u8 { ... }
│ │ │ │  }
    Expand description
    A memory allocator that can be registered as the standard library’s default
│ │ │ │  through the #[global_allocator] attribute.
    
│ │ │ │  
    Some of the methods require that a memory block be currently
│ │ │ │  allocated via an allocator. This means that:
    
│ │ │ │  
      
│ │ │ │  
    • 
│ │ │ │  
      the starting address for that memory block was previously
│ │ │ │ @@ -123,15 +123,15 @@
│ │ │ │  optimization that can be applied. You may generally not rely on heap allocations
│ │ │ │  happening if they can be removed without changing program behavior.
│ │ │ │  Whether allocations happen or not is not part of the program behavior, even if it
│ │ │ │  could be detected via an allocator that tracks allocations by printing or otherwise
│ │ │ │  having side effects.
      
│ │ │ │  
      • 
│ │ │ │  
    
│ │ │ │ -
    Required Methods§
    source
    unsafe fn alloc(&self, layout: Layout) -> *mut u8
    Allocate memory as described by the given layout.
    
│ │ │ │ +
    Required Methods§
    source
    unsafe fn alloc(&self, layout: Layout) -> *mut u8
    Allocate memory as described by the given layout.
    
│ │ │ │  
    Returns a pointer to newly-allocated memory,
│ │ │ │  or null to indicate allocation failure.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    This function is unsafe because undefined behavior can result
│ │ │ │  if the caller does not ensure that layout has non-zero size.
    
│ │ │ │  
    (Extension subtraits might provide more specific bounds on
│ │ │ │  behavior, e.g., guarantee a sentinel address or a null pointer
│ │ │ │ @@ -144,46 +144,46 @@
│ │ │ │  exhaustion rather than aborting, but this is not
│ │ │ │  a strict requirement. (Specifically: it is legal to
│ │ │ │  implement this trait atop an underlying native allocation
│ │ │ │  library that aborts on memory exhaustion.)
    
│ │ │ │  
    Clients wishing to abort computation in response to an
│ │ │ │  allocation error are encouraged to call the handle_alloc_error function,
│ │ │ │  rather than directly invoking panic! or similar.
    
│ │ │ │ -
    source
    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout)
    Deallocate the block of memory at the given ptr pointer with the given layout.
    
│ │ │ │ +
    source
    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout)
    Deallocate the block of memory at the given ptr pointer with the given layout.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    This function is unsafe because undefined behavior can result
│ │ │ │  if the caller does not ensure all of the following:
    
│ │ │ │  
      
│ │ │ │  
    • 
│ │ │ │  
      ptr must denote a block of memory currently allocated via
│ │ │ │  this allocator,
      
│ │ │ │  
      • 
│ │ │ │  
    • 
│ │ │ │  
      layout must be the same layout that was used
│ │ │ │  to allocate that block of memory.
      
│ │ │ │  
      • 
│ │ │ │  
    
│ │ │ │ -
    Provided Methods§
    source
    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8
    Behaves like alloc, but also ensures that the contents
│ │ │ │ +
    Provided Methods§
    source
    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8
    Behaves like alloc, but also ensures that the contents
│ │ │ │  are set to zero before being returned.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    This function is unsafe for the same reasons that alloc is.
│ │ │ │  However the allocated block of memory is guaranteed to be initialized.
    
│ │ │ │  
    §Errors
    
│ │ │ │  
    Returning a null pointer indicates that either memory is exhausted
│ │ │ │  or layout does not meet allocator’s size or alignment constraints,
│ │ │ │  just as in alloc.
    
│ │ │ │  
    Clients wishing to abort computation in response to an
│ │ │ │  allocation error are encouraged to call the handle_alloc_error function,
│ │ │ │  rather than directly invoking panic! or similar.
    
│ │ │ │ -
    source
    unsafe fn realloc(
│ │ │ │ +
    source
    unsafe fn realloc(
│ │ │ │      &self,
│ │ │ │ -    ptr: *mut u8,
│ │ │ │ +    ptr: *mut u8,
│ │ │ │      layout: Layout,
│ │ │ │ -    new_size: usize
│ │ │ │ -) -> *mut u8
    Shrink or grow a block of memory to the given new_size in bytes.
│ │ │ │ +    new_size: usize
│ │ │ │ +) -> *mut u8
    Shrink or grow a block of memory to the given new_size in bytes.
│ │ │ │  The block is described by the given ptr pointer and layout.
    
│ │ │ │  
    If this returns a non-null pointer, then ownership of the memory block
│ │ │ │  referenced by ptr has been transferred to this allocator.
│ │ │ │  Any access to the old ptr is Undefined Behavior, even if the
│ │ │ │  allocation remained in-place. The newly returned pointer is the only valid pointer
│ │ │ │  for accessing this memory now.
    
│ │ │ │  
    The new memory block is allocated with layout,
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/alloc/type.LayoutErr.html
│ │ │ │ @@ -1,2 +1,2 @@
│ │ │ │  LayoutErr in alloc::alloc - Rust
    
│ │ │ │ -    
    Type Alias alloc::alloc::LayoutErr
    1.28.0 · source · 
    pub type LayoutErr = LayoutError;
    👎Deprecated since 1.52.0: Name does not follow std convention, use LayoutError
    Aliased Type§
    struct LayoutErr;
    
│ │ │ │ +    
    Type Alias alloc::alloc::LayoutErr
    1.28.0 · source · 
    pub type LayoutErr = LayoutError;
    👎Deprecated since 1.52.0: Name does not follow std convention, use LayoutError
    Aliased Type§
    struct LayoutErr;
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/borrow/enum.Cow.html
│ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │  Cow in alloc::borrow - Rust
    
│ │ │ │      
    Enum alloc::borrow::Cow
    1.0.0 · source · 
    pub enum Cow<'a, B>
    where
│ │ │ │ -    B: ToOwned + ?Sized + 'a,
    {
│ │ │ │ -    Borrowed(&'a B),
│ │ │ │ +    B: ToOwned + ?Sized + 'a,
    {
│ │ │ │ +    Borrowed(&'a B),
│ │ │ │      Owned(<B as ToOwned>::Owned),
│ │ │ │  }
    Expand description

    A clone-on-write smart pointer.

    │ │ │ │

    The type Cow is a smart pointer providing clone-on-write functionality: it │ │ │ │ can enclose and provide immutable access to borrowed data, and clone the │ │ │ │ data lazily when mutation or ownership is required. The type is designed to │ │ │ │ work with general borrowed data via the Borrow trait.

    │ │ │ │

    Cow implements Deref, which means that you can call │ │ │ │ @@ -70,27 +70,27 @@ │ │ │ │ println!("clone_on_write = {:?}", clone_on_write.values); │ │ │ │ │ │ │ │ // The data was mutated. Let's check it out. │ │ │ │ match clone_on_write { │ │ │ │ Items { values: Cow::Owned(_) } => println!("clone_on_write contains owned data"), │ │ │ │ _ => panic!("expect owned data"), │ │ │ │ }Run

    │ │ │ │ -

    Variants§

    §

    Borrowed(&'a B)

    Borrowed data.

    │ │ │ │ +

    Variants§

    §

    Borrowed(&'a B)

    Borrowed data.

    │ │ │ │
    §

    Owned(<B as ToOwned>::Owned)

    Owned data.

    │ │ │ │ -

    Implementations§

    source§

    impl<B: ?Sized + ToOwned> Cow<'_, B>

    const: unstable · source

    pub fn is_borrowed(&self) -> bool

    🔬This is a nightly-only experimental API. (cow_is_borrowed #65143)

    Returns true if the data is borrowed, i.e. if to_mut would require additional work.

    │ │ │ │ +

    Implementations§

    source§

    impl<B: ?Sized + ToOwned> Cow<'_, B>

    const: unstable · source

    pub fn is_borrowed(&self) -> bool

    🔬This is a nightly-only experimental API. (cow_is_borrowed #65143)

    Returns true if the data is borrowed, i.e. if to_mut would require additional work.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(cow_is_borrowed)]
│ │ │ │  use std::borrow::Cow;
│ │ │ │  
│ │ │ │  let cow = Cow::Borrowed("moo");
│ │ │ │  assert!(cow.is_borrowed());
│ │ │ │  
│ │ │ │  let bull: Cow<'_, str> = Cow::Owned("...moo?".to_string());
│ │ │ │  assert!(!bull.is_borrowed());
    Run
    │ │ │ │ -
    const: unstable · source

    pub fn is_owned(&self) -> bool

    🔬This is a nightly-only experimental API. (cow_is_borrowed #65143)

    Returns true if the data is owned, i.e. if to_mut would be a no-op.

    │ │ │ │ +
    const: unstable · source

    pub fn is_owned(&self) -> bool

    🔬This is a nightly-only experimental API. (cow_is_borrowed #65143)

    Returns true if the data is owned, i.e. if to_mut would be a no-op.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(cow_is_borrowed)]
│ │ │ │  use std::borrow::Cow;
│ │ │ │  
│ │ │ │  let cow: Cow<'_, str> = Cow::Owned("moo".to_string());
│ │ │ │  assert!(cow.is_owned());
│ │ │ │  
│ │ │ │ @@ -130,184 +130,184 @@
│ │ │ │  let s = "Hello world!";
│ │ │ │  let cow: Cow<'_, str> = Cow::Owned(String::from(s));
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │    cow.into_owned(),
│ │ │ │    String::from(s)
│ │ │ │  );
    Run
    │ │ │ │ -

    Trait Implementations§

    1.14.0 · source§

    impl<'a> Add<&'a str> for Cow<'a, str>

    §

    type Output = Cow<'a, str>

    The resulting type after applying the + operator.
    source§

    fn add(self, rhs: &'a str) -> Self::Output

    Performs the + operation. Read more
    1.14.0 · source§

    impl<'a> Add for Cow<'a, str>

    §

    type Output = Cow<'a, str>

    The resulting type after applying the + operator.
    source§

    fn add(self, rhs: Cow<'a, str>) -> Self::Output

    Performs the + operation. Read more
    1.14.0 · source§

    impl<'a> AddAssign<&'a str> for Cow<'a, str>

    source§

    fn add_assign(&mut self, rhs: &'a str)

    Performs the += operation. Read more
    1.14.0 · source§

    impl<'a> AddAssign for Cow<'a, str>

    source§

    fn add_assign(&mut self, rhs: Cow<'a, str>)

    Performs the += operation. Read more
    source§

    impl<T: ?Sized + ToOwned> AsRef<T> for Cow<'_, T>

    source§

    fn as_ref(&self) -> &T

    Converts this type into a shared reference of the (usually inferred) input type.
    source§

    impl<'a, B> Borrow<B> for Cow<'a, B>
    where │ │ │ │ - B: ToOwned + ?Sized,

    source§

    fn borrow(&self) -> &B

    Immutably borrows from an owned value. Read more
    source§

    impl<B: ?Sized + ToOwned> Clone for Cow<'_, B>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<B> Debug for Cow<'_, B>
    where │ │ │ │ - B: Debug + ToOwned<Owned: Debug> + ?Sized,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.11.0 · source§

    impl<B> Default for Cow<'_, B>
    where │ │ │ │ - B: ToOwned<Owned: Default> + ?Sized,

    source§

    fn default() -> Self

    Creates an owned Cow<’a, B> with the default value for the contained owned value.

    │ │ │ │ -
    source§

    impl<B: ?Sized + ToOwned> Deref for Cow<'_, B>
    where │ │ │ │ - B::Owned: Borrow<B>,

    §

    type Target = B

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &B

    Dereferences the value.
    source§

    impl<B> Display for Cow<'_, B>
    where │ │ │ │ - B: Display + ToOwned<Owned: Display> + ?Sized,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.19.0 · source§

    impl<'a> Extend<Cow<'a, str>> for String

    source§

    fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, s: Cow<'a, str>)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.8.0 · source§

    impl<'a, T: Clone> From<&'a [T]> for Cow<'a, [T]>

    source§

    fn from(s: &'a [T]) -> Cow<'a, [T]>

    Creates a Borrowed variant of Cow │ │ │ │ +

    Trait Implementations§

    1.14.0 · source§

    impl<'a> Add<&'a str> for Cow<'a, str>

    §

    type Output = Cow<'a, str>

    The resulting type after applying the + operator.
    source§

    fn add(self, rhs: &'a str) -> Self::Output

    Performs the + operation. Read more
    1.14.0 · source§

    impl<'a> Add for Cow<'a, str>

    §

    type Output = Cow<'a, str>

    The resulting type after applying the + operator.
    source§

    fn add(self, rhs: Cow<'a, str>) -> Self::Output

    Performs the + operation. Read more
    1.14.0 · source§

    impl<'a> AddAssign<&'a str> for Cow<'a, str>

    source§

    fn add_assign(&mut self, rhs: &'a str)

    Performs the += operation. Read more
    1.14.0 · source§

    impl<'a> AddAssign for Cow<'a, str>

    source§

    fn add_assign(&mut self, rhs: Cow<'a, str>)

    Performs the += operation. Read more
    source§

    impl<T: ?Sized + ToOwned> AsRef<T> for Cow<'_, T>

    source§

    fn as_ref(&self) -> &T

    Converts this type into a shared reference of the (usually inferred) input type.
    source§

    impl<'a, B> Borrow<B> for Cow<'a, B>
    where │ │ │ │ + B: ToOwned + ?Sized,

    source§

    fn borrow(&self) -> &B

    Immutably borrows from an owned value. Read more
    source§

    impl<B: ?Sized + ToOwned> Clone for Cow<'_, B>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<B> Debug for Cow<'_, B>
    where │ │ │ │ + B: Debug + ToOwned<Owned: Debug> + ?Sized,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.11.0 · source§

    impl<B> Default for Cow<'_, B>
    where │ │ │ │ + B: ToOwned<Owned: Default> + ?Sized,

    source§

    fn default() -> Self

    Creates an owned Cow<’a, B> with the default value for the contained owned value.

    │ │ │ │ +
    source§

    impl<B: ?Sized + ToOwned> Deref for Cow<'_, B>
    where │ │ │ │ + B::Owned: Borrow<B>,

    §

    type Target = B

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &B

    Dereferences the value.
    source§

    impl<B> Display for Cow<'_, B>
    where │ │ │ │ + B: Display + ToOwned<Owned: Display> + ?Sized,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.19.0 · source§

    impl<'a> Extend<Cow<'a, str>> for String

    source§

    fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, s: Cow<'a, str>)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.8.0 · source§

    impl<'a, T: Clone> From<&'a [T]> for Cow<'a, [T]>

    source§

    fn from(s: &'a [T]) -> Cow<'a, [T]>

    Creates a Borrowed variant of Cow │ │ │ │ from a slice.

    │ │ │ │

    This conversion does not allocate or clone the data.

    │ │ │ │ -
    1.77.0 · source§

    impl<'a, T: Clone, const N: usize> From<&'a [T; N]> for Cow<'a, [T]>

    source§

    fn from(s: &'a [T; N]) -> Cow<'a, [T]>

    Creates a Borrowed variant of Cow │ │ │ │ +

    1.77.0 · source§

    impl<'a, T: Clone, const N: usize> From<&'a [T; N]> for Cow<'a, [T]>

    source§

    fn from(s: &'a [T; N]) -> Cow<'a, [T]>

    Creates a Borrowed variant of Cow │ │ │ │ from a reference to an array.

    │ │ │ │

    This conversion does not allocate or clone the data.

    │ │ │ │ -
    1.28.0 · source§

    impl<'a> From<&'a CStr> for Cow<'a, CStr>

    source§

    fn from(s: &'a CStr) -> Cow<'a, CStr>

    Converts a CStr into a borrowed Cow without copying or allocating.

    │ │ │ │ -
    1.28.0 · source§

    impl<'a> From<&'a CString> for Cow<'a, CStr>

    source§

    fn from(s: &'a CString) -> Cow<'a, CStr>

    Converts a &CString into a borrowed Cow without copying or allocating.

    │ │ │ │ -
    1.28.0 · source§

    impl<'a> From<&'a String> for Cow<'a, str>

    source§

    fn from(s: &'a String) -> Cow<'a, str>

    Converts a String reference into a Borrowed variant. │ │ │ │ +

    1.28.0 · source§

    impl<'a> From<&'a CStr> for Cow<'a, CStr>

    source§

    fn from(s: &'a CStr) -> Cow<'a, CStr>

    Converts a CStr into a borrowed Cow without copying or allocating.

    │ │ │ │ +
    1.28.0 · source§

    impl<'a> From<&'a CString> for Cow<'a, CStr>

    source§

    fn from(s: &'a CString) -> Cow<'a, CStr>

    Converts a &CString into a borrowed Cow without copying or allocating.

    │ │ │ │ +
    1.28.0 · source§

    impl<'a> From<&'a String> for Cow<'a, str>

    source§

    fn from(s: &'a String) -> Cow<'a, str>

    Converts a String reference into a Borrowed variant. │ │ │ │ No heap allocation is performed, and the string │ │ │ │ is not copied.

    │ │ │ │
    §Example
    │ │ │ │ 
    let s = "eggplant".to_string();
│ │ │ │  assert_eq!(Cow::from(&s), Cow::Borrowed("eggplant"));
    Run
    │ │ │ │ -
    1.28.0 · source§

    impl<'a, T: Clone> From<&'a Vec<T>> for Cow<'a, [T]>

    source§

    fn from(v: &'a Vec<T>) -> Cow<'a, [T]>

    Creates a Borrowed variant of Cow │ │ │ │ +

    1.28.0 · source§

    impl<'a, T: Clone> From<&'a Vec<T>> for Cow<'a, [T]>

    source§

    fn from(v: &'a Vec<T>) -> Cow<'a, [T]>

    Creates a Borrowed variant of Cow │ │ │ │ from a reference to Vec.

    │ │ │ │

    This conversion does not allocate or clone the data.

    │ │ │ │ -
    source§

    impl<'a> From<&'a str> for Cow<'a, str>

    source§

    fn from(s: &'a str) -> Cow<'a, str>

    Converts a string slice into a Borrowed variant. │ │ │ │ +

    source§

    impl<'a> From<&'a str> for Cow<'a, str>

    source§

    fn from(s: &'a str) -> Cow<'a, str>

    Converts a string slice into a Borrowed variant. │ │ │ │ No heap allocation is performed, and the string │ │ │ │ is not copied.

    │ │ │ │
    §Example
    │ │ │ │ 
    assert_eq!(Cow::from("eggplant"), Cow::Borrowed("eggplant"));
    Run
    │ │ │ │ -
    1.28.0 · source§

    impl<'a> From<CString> for Cow<'a, CStr>

    source§

    fn from(s: CString) -> Cow<'a, CStr>

    Converts a CString into an owned Cow without copying or allocating.

    │ │ │ │ -
    1.45.0 · source§

    impl<T: Clone> From<Cow<'_, [T]>> for Box<[T]>

    source§

    fn from(cow: Cow<'_, [T]>) -> Box<[T]>

    Converts a Cow<'_, [T]> into a Box<[T]>

    │ │ │ │ +
    1.28.0 · source§

    impl<'a> From<CString> for Cow<'a, CStr>

    source§

    fn from(s: CString) -> Cow<'a, CStr>

    Converts a CString into an owned Cow without copying or allocating.

    │ │ │ │ +
    1.45.0 · source§

    impl<T: Clone> From<Cow<'_, [T]>> for Box<[T]>

    source§

    fn from(cow: Cow<'_, [T]>) -> Box<[T]>

    Converts a Cow<'_, [T]> into a Box<[T]>

    │ │ │ │

    When cow is the Cow::Borrowed variant, this │ │ │ │ conversion allocates on the heap and copies the │ │ │ │ underlying slice. Otherwise, it will try to reuse the owned │ │ │ │ Vec’s allocation.

    │ │ │ │ -
    1.45.0 · source§

    impl From<Cow<'_, CStr>> for Box<CStr>

    source§

    fn from(cow: Cow<'_, CStr>) -> Box<CStr>

    Converts a Cow<'a, CStr> into a Box<CStr>, │ │ │ │ +

    1.45.0 · source§

    impl From<Cow<'_, CStr>> for Box<CStr>

    source§

    fn from(cow: Cow<'_, CStr>) -> Box<CStr>

    Converts a Cow<'a, CStr> into a Box<CStr>, │ │ │ │ by copying the contents if they are borrowed.

    │ │ │ │ -
    1.45.0 · source§

    impl From<Cow<'_, str>> for Box<str>

    source§

    fn from(cow: Cow<'_, str>) -> Box<str>

    Converts a Cow<'_, str> into a Box<str>

    │ │ │ │ +
    1.45.0 · source§

    impl From<Cow<'_, str>> for Box<str>

    source§

    fn from(cow: Cow<'_, str>) -> Box<str>

    Converts a Cow<'_, str> into a Box<str>

    │ │ │ │

    When cow is the Cow::Borrowed variant, this │ │ │ │ conversion allocates on the heap and copies the │ │ │ │ underlying str. Otherwise, it will try to reuse the owned │ │ │ │ String’s allocation.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::borrow::Cow;
│ │ │ │  
│ │ │ │  let unboxed = Cow::Borrowed("hello");
│ │ │ │  let boxed: Box<str> = Box::from(unboxed);
│ │ │ │  println!("{boxed}");
    Run
    │ │ │ │ │ │ │ │ 
    let unboxed = Cow::Owned("hello".to_string());
│ │ │ │  let boxed: Box<str> = Box::from(unboxed);
│ │ │ │  println!("{boxed}");
    Run
    │ │ │ │ -
    1.14.0 · source§

    impl<'a, T> From<Cow<'a, [T]>> for Vec<T>
    where │ │ │ │ - [T]: ToOwned<Owned = Vec<T>>,

    source§

    fn from(s: Cow<'a, [T]>) -> Vec<T>

    Convert a clone-on-write slice into a vector.

    │ │ │ │ +
    1.14.0 · source§

    impl<'a, T> From<Cow<'a, [T]>> for Vec<T>
    where │ │ │ │ + [T]: ToOwned<Owned = Vec<T>>,

    source§

    fn from(s: Cow<'a, [T]>) -> Vec<T>

    Convert a clone-on-write slice into a vector.

    │ │ │ │

    If s already owns a Vec<T>, it will be returned directly. │ │ │ │ If s is borrowing a slice, a new Vec<T> will be allocated and │ │ │ │ filled by cloning s’s items into it.

    │ │ │ │
    §Examples
    │ │ │ │ 
    let o: Cow<'_, [i32]> = Cow::Owned(vec![1, 2, 3]);
│ │ │ │  let b: Cow<'_, [i32]> = Cow::Borrowed(&[1, 2, 3]);
│ │ │ │  assert_eq!(Vec::from(o), Vec::from(b));
    Run
    │ │ │ │ -
    1.45.0 · source§

    impl<'a, B> From<Cow<'a, B>> for Arc<B>
    where │ │ │ │ - B: ToOwned + ?Sized, │ │ │ │ - Arc<B>: From<&'a B> + From<B::Owned>,

    source§

    fn from(cow: Cow<'a, B>) -> Arc<B>

    Create an atomically reference-counted pointer from │ │ │ │ +

    1.45.0 · source§

    impl<'a, B> From<Cow<'a, B>> for Arc<B>
    where │ │ │ │ + B: ToOwned + ?Sized, │ │ │ │ + Arc<B>: From<&'a B> + From<B::Owned>,

    source§

    fn from(cow: Cow<'a, B>) -> Arc<B>

    Create an atomically reference-counted pointer from │ │ │ │ a clone-on-write pointer by copying its content.

    │ │ │ │
    §Example
    │ │ │ │ 
    let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
│ │ │ │  let shared: Arc<str> = Arc::from(cow);
│ │ │ │  assert_eq!("eggplant", &shared[..]);
    Run
    │ │ │ │ -
    1.45.0 · source§

    impl<'a, B> From<Cow<'a, B>> for Rc<B>
    where │ │ │ │ - B: ToOwned + ?Sized, │ │ │ │ - Rc<B>: From<&'a B> + From<B::Owned>,

    source§

    fn from(cow: Cow<'a, B>) -> Rc<B>

    Create a reference-counted pointer from │ │ │ │ +

    1.45.0 · source§

    impl<'a, B> From<Cow<'a, B>> for Rc<B>
    where │ │ │ │ + B: ToOwned + ?Sized, │ │ │ │ + Rc<B>: From<&'a B> + From<B::Owned>,

    source§

    fn from(cow: Cow<'a, B>) -> Rc<B>

    Create a reference-counted pointer from │ │ │ │ a clone-on-write pointer by copying its content.

    │ │ │ │
    §Example
    │ │ │ │ 
    let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
│ │ │ │  let shared: Rc<str> = Rc::from(cow);
│ │ │ │  assert_eq!("eggplant", &shared[..]);
    Run
    │ │ │ │ -
    1.28.0 · source§

    impl<'a> From<Cow<'a, CStr>> for CString

    source§

    fn from(s: Cow<'a, CStr>) -> Self

    Converts a Cow<'a, CStr> into a CString, by copying the contents if they are │ │ │ │ +

    1.28.0 · source§

    impl<'a> From<Cow<'a, CStr>> for CString

    source§

    fn from(s: Cow<'a, CStr>) -> Self

    Converts a Cow<'a, CStr> into a CString, by copying the contents if they are │ │ │ │ borrowed.

    │ │ │ │ -
    1.14.0 · source§

    impl<'a> From<Cow<'a, str>> for String

    source§

    fn from(s: Cow<'a, str>) -> String

    Converts a clone-on-write string to an owned │ │ │ │ +

    1.14.0 · source§

    impl<'a> From<Cow<'a, str>> for String

    source§

    fn from(s: Cow<'a, str>) -> String

    Converts a clone-on-write string to an owned │ │ │ │ instance of String.

    │ │ │ │

    This extracts the owned string, │ │ │ │ clones the string if it is not already owned.

    │ │ │ │
    §Example
    │ │ │ │ 
    // If the string is not owned...
│ │ │ │  let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
│ │ │ │  // It will allocate on the heap and copy the string.
│ │ │ │  let owned: String = String::from(cow);
│ │ │ │  assert_eq!(&owned[..], "eggplant");
    Run
    │ │ │ │ -
    1.22.0 · source§

    impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a>

    source§

    fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a>

    Converts a Cow into a box of dyn Error.

    │ │ │ │ +
    1.22.0 · source§

    impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a>

    source§

    fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a>

    Converts a Cow into a box of dyn Error.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::error::Error;
│ │ │ │  use std::mem;
│ │ │ │  use std::borrow::Cow;
│ │ │ │  
│ │ │ │  let a_cow_str_error = Cow::from("a str error");
│ │ │ │  let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
│ │ │ │  assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
    Run
    │ │ │ │ -
    1.22.0 · source§

    impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>

    source§

    fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>

    Converts a Cow into a box of dyn Error + Send + Sync.

    │ │ │ │ +
    1.22.0 · source§

    impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>

    source§

    fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>

    Converts a Cow into a box of dyn Error + Send + Sync.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::error::Error;
│ │ │ │  use std::mem;
│ │ │ │  use std::borrow::Cow;
│ │ │ │  
│ │ │ │  let a_cow_str_error = Cow::from("a str error");
│ │ │ │  let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
│ │ │ │  assert!(
│ │ │ │      mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
    Run
    │ │ │ │ -
    source§

    impl<'a> From<String> for Cow<'a, str>

    source§

    fn from(s: String) -> Cow<'a, str>

    Converts a String into an Owned variant. │ │ │ │ +

    source§

    impl<'a> From<String> for Cow<'a, str>

    source§

    fn from(s: String) -> Cow<'a, str>

    Converts a String into an Owned variant. │ │ │ │ No heap allocation is performed, and the string │ │ │ │ is not copied.

    │ │ │ │
    §Example
    │ │ │ │ 
    let s = "eggplant".to_string();
│ │ │ │  let s2 = "eggplant".to_string();
│ │ │ │  assert_eq!(Cow::from(s), Cow::<'static, str>::Owned(s2));
    Run
    │ │ │ │ -
    1.8.0 · source§

    impl<'a, T: Clone> From<Vec<T>> for Cow<'a, [T]>

    source§

    fn from(v: Vec<T>) -> Cow<'a, [T]>

    Creates an Owned variant of Cow │ │ │ │ +

    1.8.0 · source§

    impl<'a, T: Clone> From<Vec<T>> for Cow<'a, [T]>

    source§

    fn from(v: Vec<T>) -> Cow<'a, [T]>

    Creates an Owned variant of Cow │ │ │ │ from an owned instance of Vec.

    │ │ │ │

    This conversion does not allocate or clone the data.

    │ │ │ │ -
    1.12.0 · source§

    impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>

    source§

    fn from_iter<I: IntoIterator<Item = &'b str>>(it: I) -> Cow<'a, str>

    Creates a value from an iterator. Read more
    1.19.0 · source§

    impl<'a> FromIterator<Cow<'a, str>> for String

    source§

    fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String

    Creates a value from an iterator. Read more
    1.12.0 · source§

    impl<'a> FromIterator<String> for Cow<'a, str>

    source§

    fn from_iter<I: IntoIterator<Item = String>>(it: I) -> Cow<'a, str>

    Creates a value from an iterator. Read more
    source§

    impl<'a, T> FromIterator<T> for Cow<'a, [T]>
    where │ │ │ │ - T: Clone,

    source§

    fn from_iter<I: IntoIterator<Item = T>>(it: I) -> Cow<'a, [T]>

    Creates a value from an iterator. Read more
    1.12.0 · source§

    impl<'a> FromIterator<char> for Cow<'a, str>

    source§

    fn from_iter<I: IntoIterator<Item = char>>(it: I) -> Cow<'a, str>

    Creates a value from an iterator. Read more
    source§

    impl<B> Hash for Cow<'_, B>
    where │ │ │ │ - B: Hash + ToOwned + ?Sized,

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ - H: Hasher, │ │ │ │ - Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<B> Ord for Cow<'_, B>
    where │ │ │ │ - B: Ord + ToOwned + ?Sized,

    source§

    fn cmp(&self, other: &Self) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ - Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<T, U> PartialEq<&[U]> for Cow<'_, [T]>
    where │ │ │ │ - T: PartialEq<U> + Clone,

    source§

    fn eq(&self, other: &&[U]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &&[U]) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<T, U> PartialEq<&mut [U]> for Cow<'_, [T]>
    where │ │ │ │ - T: PartialEq<U> + Clone,

    source§

    fn eq(&self, other: &&mut [U]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &&mut [U]) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>

    source§

    fn eq(&self, other: &&'b str) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &&'b str) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str

    source§

    fn eq(&self, other: &Cow<'a, str>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Cow<'a, str>) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<Cow<'a, str>> for String

    source§

    fn eq(&self, other: &Cow<'a, str>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Cow<'a, str>) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<Cow<'a, str>> for str

    source§

    fn eq(&self, other: &Cow<'a, str>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Cow<'a, str>) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B>
    where │ │ │ │ - B: PartialEq<C> + ToOwned + ?Sized, │ │ │ │ - C: ToOwned + ?Sized,

    source§

    fn eq(&self, other: &Cow<'b, C>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<String> for Cow<'a, str>

    source§

    fn eq(&self, other: &String) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &String) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for Cow<'_, [T]>
    where │ │ │ │ - T: PartialEq<U> + Clone,

    source§

    fn eq(&self, other: &Vec<U, A>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Vec<U, A>) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<str> for Cow<'a, str>

    source§

    fn eq(&self, other: &str) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &str) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, B> PartialOrd for Cow<'a, B>
    where │ │ │ │ - B: PartialOrd + ToOwned + ?Sized,

    source§

    fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ -operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ -operator. Read more
    source§

    impl<B> Eq for Cow<'_, B>
    where │ │ │ │ - B: Eq + ToOwned + ?Sized,

    Auto Trait Implementations§

    §

    impl<'a, B: ?Sized> Freeze for Cow<'a, B>
    where │ │ │ │ - <B as ToOwned>::Owned: Freeze,

    §

    impl<'a, B: ?Sized> RefUnwindSafe for Cow<'a, B>
    where │ │ │ │ - B: RefUnwindSafe, │ │ │ │ - <B as ToOwned>::Owned: RefUnwindSafe,

    §

    impl<'a, B: ?Sized> Send for Cow<'a, B>
    where │ │ │ │ - B: Sync, │ │ │ │ - <B as ToOwned>::Owned: Send,

    §

    impl<'a, B: ?Sized> Sync for Cow<'a, B>
    where │ │ │ │ - B: Sync, │ │ │ │ - <B as ToOwned>::Owned: Sync,

    §

    impl<'a, B: ?Sized> Unpin for Cow<'a, B>
    where │ │ │ │ - <B as ToOwned>::Owned: Unpin,

    §

    impl<'a, B: ?Sized> UnwindSafe for Cow<'a, B>
    where │ │ │ │ - B: RefUnwindSafe, │ │ │ │ - <B as ToOwned>::Owned: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +
    1.12.0 · source§

    impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>

    source§

    fn from_iter<I: IntoIterator<Item = &'b str>>(it: I) -> Cow<'a, str>

    Creates a value from an iterator. Read more
    1.19.0 · source§

    impl<'a> FromIterator<Cow<'a, str>> for String

    source§

    fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String

    Creates a value from an iterator. Read more
    1.12.0 · source§

    impl<'a> FromIterator<String> for Cow<'a, str>

    source§

    fn from_iter<I: IntoIterator<Item = String>>(it: I) -> Cow<'a, str>

    Creates a value from an iterator. Read more
    source§

    impl<'a, T> FromIterator<T> for Cow<'a, [T]>
    where │ │ │ │ + T: Clone,

    source§

    fn from_iter<I: IntoIterator<Item = T>>(it: I) -> Cow<'a, [T]>

    Creates a value from an iterator. Read more
    1.12.0 · source§

    impl<'a> FromIterator<char> for Cow<'a, str>

    source§

    fn from_iter<I: IntoIterator<Item = char>>(it: I) -> Cow<'a, str>

    Creates a value from an iterator. Read more
    source§

    impl<B> Hash for Cow<'_, B>
    where │ │ │ │ + B: Hash + ToOwned + ?Sized,

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ + H: Hasher, │ │ │ │ + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<B> Ord for Cow<'_, B>
    where │ │ │ │ + B: Ord + ToOwned + ?Sized,

    source§

    fn cmp(&self, other: &Self) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ + Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<T, U> PartialEq<&[U]> for Cow<'_, [T]>
    where │ │ │ │ + T: PartialEq<U> + Clone,

    source§

    fn eq(&self, other: &&[U]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &&[U]) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<T, U> PartialEq<&mut [U]> for Cow<'_, [T]>
    where │ │ │ │ + T: PartialEq<U> + Clone,

    source§

    fn eq(&self, other: &&mut [U]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &&mut [U]) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>

    source§

    fn eq(&self, other: &&'b str) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &&'b str) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str

    source§

    fn eq(&self, other: &Cow<'a, str>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Cow<'a, str>) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<Cow<'a, str>> for String

    source§

    fn eq(&self, other: &Cow<'a, str>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Cow<'a, str>) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<Cow<'a, str>> for str

    source§

    fn eq(&self, other: &Cow<'a, str>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Cow<'a, str>) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B>
    where │ │ │ │ + B: PartialEq<C> + ToOwned + ?Sized, │ │ │ │ + C: ToOwned + ?Sized,

    source§

    fn eq(&self, other: &Cow<'b, C>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<String> for Cow<'a, str>

    source§

    fn eq(&self, other: &String) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &String) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for Cow<'_, [T]>
    where │ │ │ │ + T: PartialEq<U> + Clone,

    source§

    fn eq(&self, other: &Vec<U, A>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Vec<U, A>) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, 'b> PartialEq<str> for Cow<'a, str>

    source§

    fn eq(&self, other: &str) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &str) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<'a, B> PartialOrd for Cow<'a, B>
    where │ │ │ │ + B: PartialOrd + ToOwned + ?Sized,

    source§

    fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ +operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ +operator. Read more
    source§

    impl<B> Eq for Cow<'_, B>
    where │ │ │ │ + B: Eq + ToOwned + ?Sized,

    Auto Trait Implementations§

    §

    impl<'a, B: ?Sized> Freeze for Cow<'a, B>
    where │ │ │ │ + <B as ToOwned>::Owned: Freeze,

    §

    impl<'a, B: ?Sized> RefUnwindSafe for Cow<'a, B>
    where │ │ │ │ + B: RefUnwindSafe, │ │ │ │ + <B as ToOwned>::Owned: RefUnwindSafe,

    §

    impl<'a, B: ?Sized> Send for Cow<'a, B>
    where │ │ │ │ + B: Sync, │ │ │ │ + <B as ToOwned>::Owned: Send,

    §

    impl<'a, B: ?Sized> Sync for Cow<'a, B>
    where │ │ │ │ + B: Sync, │ │ │ │ + <B as ToOwned>::Owned: Sync,

    §

    impl<'a, B: ?Sized> Unpin for Cow<'a, B>
    where │ │ │ │ + <B as ToOwned>::Owned: Unpin,

    §

    impl<'a, B: ?Sized> UnwindSafe for Cow<'a, B>
    where │ │ │ │ + B: RefUnwindSafe, │ │ │ │ + <B as ToOwned>::Owned: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/borrow/trait.Borrow.html │ │ │ │ @@ -1,21 +1,21 @@ │ │ │ │ Borrow in alloc::borrow - Rust
    │ │ │ │ -

    Trait alloc::borrow::Borrow

    1.0.0 · source · 
    pub trait Borrow<Borrowed>
    where
│ │ │ │ -    Borrowed: ?Sized,
    {
│ │ │ │ +    
    Trait alloc::borrow::Borrow
    1.0.0 · source · 
    pub trait Borrow<Borrowed>
    where
│ │ │ │ +    Borrowed: ?Sized,
    {
│ │ │ │      // Required method
│ │ │ │ -    fn borrow(&self) -> &Borrowed;
│ │ │ │ +    fn borrow(&self) -> &Borrowed;
│ │ │ │  }
    Expand description
    A trait for borrowing data.
    
│ │ │ │  
    In Rust, it is common to provide different representations of a type for
│ │ │ │  different use cases. For instance, storage location and management for a
│ │ │ │  value can be specifically chosen as appropriate for a particular use via
│ │ │ │  pointer types such as Box<T> or Rc<T>. Beyond these generic
│ │ │ │  wrappers that can be used with any type, some types provide optional
│ │ │ │  facets providing potentially costly functionality. An example for such a
│ │ │ │  type is String which adds the ability to extend a string to the basic
│ │ │ │ -str. This requires keeping additional information unnecessary for a
│ │ │ │ +str. This requires keeping additional information unnecessary for a
│ │ │ │  simple, immutable string.
    
│ │ │ │  
    These types provide access to the underlying data through references
│ │ │ │  to the type of that data. They are said to be ‘borrowed as’ that type.
│ │ │ │  For instance, a Box<T> can be borrowed as T while a String
│ │ │ │  can be borrowed as str.
    
│ │ │ │  
    Types express that they can be borrowed as some type T by implementing
│ │ │ │  Borrow<T>, providing a reference to a T in the trait’s
│ │ │ │ @@ -29,22 +29,22 @@
│ │ │ │  on the identical behavior of these additional trait implementations.
│ │ │ │  These traits will likely appear as additional trait bounds.
    
│ │ │ │  
    In particular Eq, Ord and Hash must be equivalent for
│ │ │ │  borrowed and owned values: x.borrow() == y.borrow() should give the
│ │ │ │  same result as x == y.
    
│ │ │ │  
    If generic code merely needs to work for all types that can
│ │ │ │  provide a reference to related type T, it is often better to use
│ │ │ │ -AsRef<T> as more types can safely implement it.
    
│ │ │ │ +AsRef<T> as more types can safely implement it.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    As a data collection, HashMap<K, V> owns both keys and values. If
│ │ │ │  the key’s actual data is wrapped in a managing type of some kind, it
│ │ │ │  should, however, still be possible to search for a value using a
│ │ │ │  reference to the key’s data. For instance, if the key is a string, then
│ │ │ │  it is likely stored with the hash map as a String, while it should
│ │ │ │ -be possible to search using a &str. Thus, insert needs to
│ │ │ │ +be possible to search using a &str. Thus, insert needs to
│ │ │ │  operate on a String while get needs to be able to use a &str.
    
│ │ │ │  
    Slightly simplified, the relevant parts of HashMap<K, V> look like
│ │ │ │  this:
    
│ │ │ │  
│ │ │ │  
    use std::borrow::Borrow;
│ │ │ │  use std::hash::Hash;
│ │ │ │  
│ │ │ │ @@ -112,27 +112,27 @@
│ │ │ │  }
    Run
    
│ │ │ │  
    Can CaseInsensitiveString implement Borrow<str>? It certainly can
│ │ │ │  provide a reference to a string slice via its contained owned string.
│ │ │ │  But because its Hash implementation differs, it behaves differently
│ │ │ │  from str and therefore must not, in fact, implement Borrow<str>.
│ │ │ │  If it wants to allow others access to the underlying str, it can do
│ │ │ │  that via AsRef<str> which doesn’t carry any extra requirements.
    
│ │ │ │ -
    Required Methods§
    source
    fn borrow(&self) -> &Borrowed
    Immutably borrows from an owned value.
    
│ │ │ │ +
    Required Methods§
    source
    fn borrow(&self) -> &Borrowed
    Immutably borrows from an owned value.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::borrow::Borrow;
│ │ │ │  
│ │ │ │  fn check<T: Borrow<str>>(s: T) {
│ │ │ │      assert_eq!("Hello", s.borrow());
│ │ │ │  }
│ │ │ │  
│ │ │ │  let s = "Hello".to_string();
│ │ │ │  
│ │ │ │  check(s);
│ │ │ │  
│ │ │ │  let s = "Hello";
│ │ │ │  
│ │ │ │  check(s);
    Run
    
│ │ │ │ -
    Implementors§
    source§
    impl Borrow<str> for String
    1.3.0 · source§
    impl Borrow<CStr> for CString
    source§
    impl<'a, B> Borrow<B> for Cow<'a, B>
    where
│ │ │ │ -    B: ToOwned + ?Sized,
    source§
    impl<T> Borrow<T> for &T
    where
│ │ │ │ -    T: ?Sized,
    source§
    impl<T> Borrow<T> for &mut T
    where
│ │ │ │ -    T: ?Sized,
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    impl<T, A: Allocator> Borrow<[T]> for Vec<T, A>
    1.4.0 · source§
    impl<T, const N: usize> Borrow<[T]> for [T; N]
    1.1.0 · source§
    impl<T: ?Sized, A: Allocator> Borrow<T> for Box<T, A>
    source§
    impl<T: ?Sized, A: Allocator> Borrow<T> for Rc<T, A>
    source§
    impl<T: ?Sized, A: Allocator> Borrow<T> for Arc<T, A>
    
│ │ │ │ +

    Implementors§

    source§

    impl Borrow<str> for String

    1.3.0 · source§

    impl Borrow<CStr> for CString

    source§

    impl<'a, B> Borrow<B> for Cow<'a, B>
    where │ │ │ │ + B: ToOwned + ?Sized,

    source§

    impl<T> Borrow<T> for &T
    where │ │ │ │ + T: ?Sized,

    source§

    impl<T> Borrow<T> for &mut T
    where │ │ │ │ + T: ?Sized,

    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    impl<T, A: Allocator> Borrow<[T]> for Vec<T, A>

    1.4.0 · source§

    impl<T, const N: usize> Borrow<[T]> for [T; N]

    1.1.0 · source§

    impl<T: ?Sized, A: Allocator> Borrow<T> for Box<T, A>

    source§

    impl<T: ?Sized, A: Allocator> Borrow<T> for Rc<T, A>

    source§

    impl<T: ?Sized, A: Allocator> Borrow<T> for Arc<T, A>

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/borrow/trait.BorrowMut.html │ │ │ │ @@ -1,23 +1,23 @@ │ │ │ │ BorrowMut in alloc::borrow - Rust
    │ │ │ │ -

    Trait alloc::borrow::BorrowMut

    1.0.0 · source · 
    pub trait BorrowMut<Borrowed>: Borrow<Borrowed>
    where
│ │ │ │ -    Borrowed: ?Sized,
    {
│ │ │ │ +    
    Trait alloc::borrow::BorrowMut
    1.0.0 · source · 
    pub trait BorrowMut<Borrowed>: Borrow<Borrowed>
    where
│ │ │ │ +    Borrowed: ?Sized,
    {
│ │ │ │      // Required method
│ │ │ │ -    fn borrow_mut(&mut self) -> &mut Borrowed;
│ │ │ │ +    fn borrow_mut(&mut self) -> &mut Borrowed;
│ │ │ │  }
    Expand description
    A trait for mutably borrowing data.
    
│ │ │ │  
    As a companion to Borrow<T> this trait allows a type to borrow as
│ │ │ │  an underlying type by providing a mutable reference. See Borrow<T>
│ │ │ │  for more information on borrowing as another type.
    
│ │ │ │ -
    Required Methods§
    source
    fn borrow_mut(&mut self) -> &mut Borrowed
    Mutably borrows from an owned value.
    
│ │ │ │ +
    Required Methods§
    source
    fn borrow_mut(&mut self) -> &mut Borrowed
    Mutably borrows from an owned value.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::borrow::BorrowMut;
│ │ │ │  
│ │ │ │  fn check<T: BorrowMut<[i32]>>(mut v: T) {
│ │ │ │      assert_eq!(&mut [1, 2, 3], v.borrow_mut());
│ │ │ │  }
│ │ │ │  
│ │ │ │  let v = vec![1, 2, 3];
│ │ │ │  
│ │ │ │  check(v);
    Run
    
│ │ │ │ -
    Implementors§
    1.36.0 · source§
    impl BorrowMut<str> for String
    source§
    impl<T> BorrowMut<T> for &mut T
    where
│ │ │ │ -    T: ?Sized,
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    impl<T, A: Allocator> BorrowMut<[T]> for Vec<T, A>
    1.4.0 · source§
    impl<T, const N: usize> BorrowMut<[T]> for [T; N]
    1.1.0 · source§
    impl<T: ?Sized, A: Allocator> BorrowMut<T> for Box<T, A>
    
│ │ │ │ +

    Implementors§

    1.36.0 · source§

    impl BorrowMut<str> for String

    source§

    impl<T> BorrowMut<T> for &mut T
    where │ │ │ │ + T: ?Sized,

    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    impl<T, A: Allocator> BorrowMut<[T]> for Vec<T, A>

    1.4.0 · source§

    impl<T, const N: usize> BorrowMut<[T]> for [T; N]

    1.1.0 · source§

    impl<T: ?Sized, A: Allocator> BorrowMut<T> for Box<T, A>

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/borrow/trait.ToOwned.html │ │ │ │ @@ -19,18 +19,18 @@ │ │ │ │ │ │ │ │ 
    let s: &str = "a";
│ │ │ │  let ss: String = s.to_owned();
│ │ │ │  
│ │ │ │  let v: &[i32] = &[1, 2];
│ │ │ │  let vv: Vec<i32> = v.to_owned();
    Run
    │ │ │ │

    Provided Methods§

    1.63.0 · source

    fn clone_into(&self, target: &mut Self::Owned)

    Uses borrowed data to replace owned data, usually by cloning.

    │ │ │ │ -

    This is borrow-generalized version of Clone::clone_from.

    │ │ │ │ +

    This is borrow-generalized version of Clone::clone_from.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    let mut s: String = String::new();
│ │ │ │  "hello".clone_into(&mut s);
│ │ │ │  
│ │ │ │  let mut v: Vec<i32> = Vec::new();
│ │ │ │  [1, 2][..].clone_into(&mut v);
    Run
    │ │ │ │ -

    Object Safety§

    This trait is not object safe.

    Implementors§

    source§

    impl ToOwned for str

    §

    type Owned = String

    1.3.0 · source§

    impl ToOwned for CStr

    §

    type Owned = CString

    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    source§

    impl<T: Clone> ToOwned for [T]

    §

    type Owned = Vec<T>

    │ │ │ │ +

    Object Safety§

    This trait is not object safe.

    Implementors§

    source§

    impl ToOwned for str

    §

    type Owned = String

    1.3.0 · source§

    impl ToOwned for CStr

    §

    type Owned = CString

    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    source§

    impl<T: Clone> ToOwned for [T]

    §

    type Owned = Vec<T>

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/boxed/index.html │ │ │ │ @@ -5,15 +5,15 @@ │ │ │ │ drop their contents when they go out of scope. Boxes also ensure that they │ │ │ │ never allocate more than isize::MAX bytes.

    │ │ │ │

    §Examples

    │ │ │ │

    Move a value from the stack to the heap by creating a Box:

    │ │ │ │ │ │ │ │ 
    let val: u8 = 5;
│ │ │ │  let boxed: Box<u8> = Box::new(val);
    Run
    │ │ │ │ -

    Move a value from a Box back to the stack by dereferencing:

    │ │ │ │ +

    Move a value from a Box back to the stack by dereferencing:

    │ │ │ │ │ │ │ │ 
    let boxed: Box<u8> = Box::new(5);
│ │ │ │  let val: u8 = *boxed;
    Run
    │ │ │ │

    Creating a recursive data structure:

    │ │ │ │ │ │ │ │ 
    #[allow(dead_code)]
│ │ │ │  #[derive(Debug)]
│ │ │ │ @@ -38,20 +38,20 @@
│ │ │ │  its allocation. It is valid to convert both ways between a Box and a
│ │ │ │  raw pointer allocated with the Global allocator, given that the
│ │ │ │  Layout used with the allocator is correct for the type. More precisely,
│ │ │ │  a value: *mut T that has been allocated with the Global allocator
│ │ │ │  with Layout::for_value(&*value) may be converted into a box using
│ │ │ │  Box::<T>::from_raw(value). Conversely, the memory backing a value: *mut T obtained from Box::<T>::into_raw may be deallocated using the
│ │ │ │  Global allocator with Layout::for_value(&*value).
    
│ │ │ │ -
    For zero-sized values, the Box pointer still has to be valid for reads
│ │ │ │ +
    For zero-sized values, the Box pointer still has to be valid for reads
│ │ │ │  and writes and sufficiently aligned. In particular, casting any aligned
│ │ │ │  non-zero integer literal to a raw pointer produces a valid pointer, but a
│ │ │ │  pointer pointing into previously allocated memory that since got freed is
│ │ │ │  not valid. The recommended way to build a Box to a ZST if Box::new cannot
│ │ │ │ -be used is to use ptr::NonNull::dangling.
    
│ │ │ │ +be used is to use ptr::NonNull::dangling.
    
│ │ │ │  
    So long as T: Sized, a Box<T> is guaranteed to be represented
│ │ │ │  as a single pointer and is also ABI-compatible with C pointers
│ │ │ │  (i.e. the C type T*). This means that if you have extern “C”
│ │ │ │  Rust functions that will be called from C, you can define those
│ │ │ │  Rust functions using Box<T> types, and use T* as corresponding
│ │ │ │  type on the C side. As an example, consider this C header which
│ │ │ │  declares functions that create and destroy some kind of Foo
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/boxed/struct.Box.html
│ │ │ │ @@ -1,70 +1,70 @@
│ │ │ │  Box in alloc::boxed - Rust
    
│ │ │ │ -    
    Struct alloc::boxed::Box
    1.0.0 · source · 
    pub struct Box<T: ?Sized, A: Allocator = Global>(/* private fields */);
    Expand description
    A pointer type that uniquely owns a heap allocation of type T.
    
│ │ │ │ +    
    Struct alloc::boxed::Box
    1.0.0 · source · 
    pub struct Box<T: ?Sized, A: Allocator = Global>(/* private fields */);
    Expand description
    A pointer type that uniquely owns a heap allocation of type T.
    
│ │ │ │  
    See the module-level documentation for more.
    
│ │ │ │  
    Implementations§
    source§
    impl<T> Box<T>
    source
    pub fn new(x: T) -> Self
    Allocates memory on the heap and then places x into it.
    
│ │ │ │  
    This doesn’t actually allocate if T is zero-sized.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let five = Box::new(5);
    Run
    
│ │ │ │ -
    source
    pub fn new_uninit() -> Box<MaybeUninit<T>>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new box with uninitialized contents.
    
│ │ │ │ +
    source
    pub fn new_uninit() -> Box<MaybeUninit<T>>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new box with uninitialized contents.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  
│ │ │ │  let mut five = Box::<u32>::new_uninit();
│ │ │ │  
│ │ │ │  let five = unsafe {
│ │ │ │      // Deferred initialization:
│ │ │ │      five.as_mut_ptr().write(5);
│ │ │ │  
│ │ │ │      five.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5)
    Run
    
│ │ │ │ -
    source
    pub fn new_zeroed() -> Box<MaybeUninit<T>>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new Box with uninitialized contents, with the memory
│ │ │ │ +
    source
    pub fn new_zeroed() -> Box<MaybeUninit<T>>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new Box with uninitialized contents, with the memory
│ │ │ │  being filled with 0 bytes.
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │  of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  
│ │ │ │  let zero = Box::<u32>::new_zeroed();
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*zero, 0)
    Run
    
│ │ │ │ -
    1.33.0 · source
    pub fn pin(x: T) -> Pin<Box<T>>
    Constructs a new Pin<Box<T>>. If T does not implement Unpin, then
│ │ │ │ +
    1.33.0 · source
    pub fn pin(x: T) -> Pin<Box<T>>
    Constructs a new Pin<Box<T>>. If T does not implement Unpin, then
│ │ │ │  x will be pinned in memory and unable to be moved.
    
│ │ │ │  
    Constructing and pinning of the Box can also be done in two steps: Box::pin(x)
│ │ │ │  does the same as Box::into_pin(Box::new(x)). Consider using
│ │ │ │  into_pin if you already have a Box<T>, or if you want to
│ │ │ │  construct a (pinned) Box in a different way than with Box::new.
    
│ │ │ │ -
    source
    pub fn try_new(x: T) -> Result<Self, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Allocates memory on the heap then places x into it,
│ │ │ │ +
    source
    pub fn try_new(x: T) -> Result<Self, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Allocates memory on the heap then places x into it,
│ │ │ │  returning an error if the allocation fails
    
│ │ │ │  
    This doesn’t actually allocate if T is zero-sized.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  let five = Box::try_new(5)?;
    Run
    
│ │ │ │ -
    source
    pub fn try_new_uninit() -> Result<Box<MaybeUninit<T>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new box with uninitialized contents on the heap,
│ │ │ │ +
    source
    pub fn try_new_uninit() -> Result<Box<MaybeUninit<T>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new box with uninitialized contents on the heap,
│ │ │ │  returning an error if the allocation fails
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  let mut five = Box::<u32>::try_new_uninit()?;
│ │ │ │  
│ │ │ │  let five = unsafe {
│ │ │ │      // Deferred initialization:
│ │ │ │      five.as_mut_ptr().write(5);
│ │ │ │  
│ │ │ │      five.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5);
    Run
    
│ │ │ │ -
    source
    pub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Box with uninitialized contents, with the memory
│ │ │ │ +
    source
    pub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Box with uninitialized contents, with the memory
│ │ │ │  being filled with 0 bytes on the heap
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │  of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  let zero = Box::<u32>::try_new_zeroed()?;
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │ @@ -74,25 +74,25 @@
│ │ │ │  
    This doesn’t actually allocate if T is zero-sized.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let five = Box::new_in(5, System);
    Run
    
│ │ │ │ -
    source
    pub fn try_new_in(x: T, alloc: A) -> Result<Self, AllocError>
    where
│ │ │ │ +
    source
    pub fn try_new_in(x: T, alloc: A) -> Result<Self, AllocError>
    where
│ │ │ │      A: Allocator,
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Allocates memory in the given allocator then places x into it,
│ │ │ │  returning an error if the allocation fails
    
│ │ │ │  
    This doesn’t actually allocate if T is zero-sized.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let five = Box::try_new_in(5, System)?;
    Run
    
│ │ │ │ -
    source
    pub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>
    where
│ │ │ │ +
    source
    pub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>
    where
│ │ │ │      A: Allocator,
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new box with uninitialized contents in the provided allocator.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let mut five = Box::<u32, _>::new_uninit_in(System);
│ │ │ │ @@ -101,15 +101,15 @@
│ │ │ │      // Deferred initialization:
│ │ │ │      five.as_mut_ptr().write(5);
│ │ │ │  
│ │ │ │      five.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5)
    Run
    
│ │ │ │ -
    source
    pub fn try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>
    where
│ │ │ │ +
    source
    pub fn try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>
    where
│ │ │ │      A: Allocator,
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new box with uninitialized contents in the provided allocator,
│ │ │ │  returning an error if the allocation fails
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │ @@ -119,60 +119,60 @@
│ │ │ │      // Deferred initialization:
│ │ │ │      five.as_mut_ptr().write(5);
│ │ │ │  
│ │ │ │      five.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5);
    Run
    
│ │ │ │ -
    source
    pub fn new_zeroed_in(alloc: A) -> Box<MaybeUninit<T>, A>
    where
│ │ │ │ +
    source
    pub fn new_zeroed_in(alloc: A) -> Box<MaybeUninit<T>, A>
    where
│ │ │ │      A: Allocator,
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Box with uninitialized contents, with the memory
│ │ │ │  being filled with 0 bytes in the provided allocator.
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │  of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let zero = Box::<u32, _>::new_zeroed_in(System);
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*zero, 0)
    Run
    
│ │ │ │ -
    source
    pub fn try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>
    where
│ │ │ │ +
    source
    pub fn try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>
    where
│ │ │ │      A: Allocator,
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Box with uninitialized contents, with the memory
│ │ │ │  being filled with 0 bytes in the provided allocator,
│ │ │ │  returning an error if the allocation fails,
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │  of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let zero = Box::<u32, _>::try_new_zeroed_in(System)?;
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*zero, 0);
    Run
    
│ │ │ │ -
    source
    pub fn pin_in(x: T, alloc: A) -> Pin<Self>
    where
│ │ │ │ -    A: 'static + Allocator,
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Pin<Box<T, A>>. If T does not implement Unpin, then
│ │ │ │ +
    source
    pub fn pin_in(x: T, alloc: A) -> Pin<Self>
    where
│ │ │ │ +    A: 'static + Allocator,
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Pin<Box<T, A>>. If T does not implement Unpin, then
│ │ │ │  x will be pinned in memory and unable to be moved.
    
│ │ │ │  
    Constructing and pinning of the Box can also be done in two steps: Box::pin_in(x, alloc)
│ │ │ │  does the same as Box::into_pin(Box::new_in(x, alloc)). Consider using
│ │ │ │  into_pin if you already have a Box<T, A>, or if you want to
│ │ │ │  construct a (pinned) Box in a different way than with Box::new_in.
    
│ │ │ │ -
    source
    pub fn into_boxed_slice(boxed: Self) -> Box<[T], A>
    🔬This is a nightly-only experimental API. (box_into_boxed_slice #71582)
    Converts a Box<T> into a Box<[T]>
    
│ │ │ │ +
    source
    pub fn into_boxed_slice(boxed: Self) -> Box<[T], A>
    🔬This is a nightly-only experimental API. (box_into_boxed_slice #71582)
    Converts a Box<T> into a Box<[T]>
    
│ │ │ │  
    This conversion does not allocate on the heap and happens in place.
    
│ │ │ │  
    source
    pub fn into_inner(boxed: Self) -> T
    🔬This is a nightly-only experimental API. (box_into_inner #80437)
    Consumes the Box, returning the wrapped value.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(box_into_inner)]
│ │ │ │  
│ │ │ │  let c = Box::new(5);
│ │ │ │  
│ │ │ │  assert_eq!(Box::into_inner(c), 5);
    Run
    
│ │ │ │ -
    source§
    impl<T> Box<[T]>
    source
    pub fn new_uninit_slice(len: usize) -> Box<[MaybeUninit<T>]>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new boxed slice with uninitialized contents.
    
│ │ │ │ +
    source§
    impl<T> Box<[T]>
    source
    pub fn new_uninit_slice(len: usize) -> Box<[MaybeUninit<T>]>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new boxed slice with uninitialized contents.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  
│ │ │ │  let mut values = Box::<[u32]>::new_uninit_slice(3);
│ │ │ │  
│ │ │ │  let values = unsafe {
│ │ │ │      // Deferred initialization:
│ │ │ │ @@ -180,28 +180,28 @@
│ │ │ │      values[1].as_mut_ptr().write(2);
│ │ │ │      values[2].as_mut_ptr().write(3);
│ │ │ │  
│ │ │ │      values.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [1, 2, 3])
    Run
    
│ │ │ │ -
    source
    pub fn new_zeroed_slice(len: usize) -> Box<[MaybeUninit<T>]>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new boxed slice with uninitialized contents, with the memory
│ │ │ │ +
    source
    pub fn new_zeroed_slice(len: usize) -> Box<[MaybeUninit<T>]>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new boxed slice with uninitialized contents, with the memory
│ │ │ │  being filled with 0 bytes.
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │  of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  
│ │ │ │  let values = Box::<[u32]>::new_zeroed_slice(3);
│ │ │ │  let values = unsafe { values.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [0, 0, 0])
    Run
    
│ │ │ │  
    source
    pub fn try_new_uninit_slice(
│ │ │ │ -    len: usize
│ │ │ │ -) -> Result<Box<[MaybeUninit<T>]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new boxed slice with uninitialized contents. Returns an error if
│ │ │ │ +    len: usize
│ │ │ │ +) -> Result<Box<[MaybeUninit<T>]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new boxed slice with uninitialized contents. Returns an error if
│ │ │ │  the allocation fails
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  let mut values = Box::<[u32]>::try_new_uninit_slice(3)?;
│ │ │ │  let values = unsafe {
│ │ │ │      // Deferred initialization:
│ │ │ │ @@ -209,27 +209,27 @@
│ │ │ │      values[1].as_mut_ptr().write(2);
│ │ │ │      values[2].as_mut_ptr().write(3);
│ │ │ │      values.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [1, 2, 3]);
    Run
    
│ │ │ │  
    source
    pub fn try_new_zeroed_slice(
│ │ │ │ -    len: usize
│ │ │ │ -) -> Result<Box<[MaybeUninit<T>]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new boxed slice with uninitialized contents, with the memory
│ │ │ │ +    len: usize
│ │ │ │ +) -> Result<Box<[MaybeUninit<T>]>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new boxed slice with uninitialized contents, with the memory
│ │ │ │  being filled with 0 bytes. Returns an error if the allocation fails
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │  of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  let values = Box::<[u32]>::try_new_zeroed_slice(3)?;
│ │ │ │  let values = unsafe { values.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [0, 0, 0]);
    Run
    
│ │ │ │ -
    source§
    impl<T, A: Allocator> Box<[T], A>
    source
    pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new boxed slice with uninitialized contents in the provided allocator.
    
│ │ │ │ +
    source§
    impl<T, A: Allocator> Box<[T], A>
    source
    pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new boxed slice with uninitialized contents in the provided allocator.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let mut values = Box::<[u32], _>::new_uninit_slice_in(3, System);
│ │ │ │  
│ │ │ │ @@ -239,30 +239,30 @@
│ │ │ │      values[1].as_mut_ptr().write(2);
│ │ │ │      values[2].as_mut_ptr().write(3);
│ │ │ │  
│ │ │ │      values.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [1, 2, 3])
    Run
    
│ │ │ │ -
    source
    pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new boxed slice with uninitialized contents in the provided allocator,
│ │ │ │ +
    source
    pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new boxed slice with uninitialized contents in the provided allocator,
│ │ │ │  with the memory being filled with 0 bytes.
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │  of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let values = Box::<[u32], _>::new_zeroed_slice_in(3, System);
│ │ │ │  let values = unsafe { values.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [0, 0, 0])
    Run
    
│ │ │ │ -
    source§
    impl<T, A: Allocator> Box<MaybeUninit<T>, A>
    source
    pub unsafe fn assume_init(self) -> Box<T, A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Converts to Box<T, A>.
    
│ │ │ │ +
    source§
    impl<T, A: Allocator> Box<MaybeUninit<T>, A>
    source
    pub unsafe fn assume_init(self) -> Box<T, A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Converts to Box<T, A>.
    
│ │ │ │  
    §Safety
    
│ │ │ │ -
    As with MaybeUninit::assume_init,
│ │ │ │ +
    As with MaybeUninit::assume_init,
│ │ │ │  it is up to the caller to guarantee that the value
│ │ │ │  really is in an initialized state.
│ │ │ │  Calling this when the content is not yet fully initialized
│ │ │ │  causes immediate undefined behavior.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  
│ │ │ │ @@ -294,17 +294,17 @@
│ │ │ │  // The optimizer may be able to elide this copy, so previous code writes
│ │ │ │  // to heap directly.
│ │ │ │  let big_box = Box::write(big_box, array);
│ │ │ │  
│ │ │ │  for (i, x) in big_box.iter().enumerate() {
│ │ │ │      assert_eq!(*x, i);
│ │ │ │  }
    Run
    
│ │ │ │ -
    source§
    impl<T, A: Allocator> Box<[MaybeUninit<T>], A>
    source
    pub unsafe fn assume_init(self) -> Box<[T], A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Converts to Box<[T], A>.
    
│ │ │ │ +
    source§
    impl<T, A: Allocator> Box<[MaybeUninit<T>], A>
    source
    pub unsafe fn assume_init(self) -> Box<[T], A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Converts to Box<[T], A>.
    
│ │ │ │  
    §Safety
    
│ │ │ │ -
    As with MaybeUninit::assume_init,
│ │ │ │ +
    As with MaybeUninit::assume_init,
│ │ │ │  it is up to the caller to guarantee that the values
│ │ │ │  really are in an initialized state.
│ │ │ │  Calling this when the content is not yet fully initialized
│ │ │ │  causes immediate undefined behavior.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  
│ │ │ │ @@ -316,15 +316,15 @@
│ │ │ │      values[1].as_mut_ptr().write(2);
│ │ │ │      values[2].as_mut_ptr().write(3);
│ │ │ │  
│ │ │ │      values.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [1, 2, 3])
    Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized> Box<T>
    1.4.0 · source
    pub unsafe fn from_raw(raw: *mut T) -> Self
    Constructs a box from a raw pointer.
    
│ │ │ │ +
    source§
    impl<T: ?Sized> Box<T>
    1.4.0 · source
    pub unsafe fn from_raw(raw: *mut T) -> Self
    Constructs a box from a raw pointer.
    
│ │ │ │  
    After calling this function, the raw pointer is owned by the
│ │ │ │  resulting Box. Specifically, the Box destructor will call
│ │ │ │  the destructor of T and free the allocated memory. For this
│ │ │ │  to be safe, the memory must have been allocated in accordance
│ │ │ │  with the memory layout used by Box .
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    This function is unsafe because improper use may lead to
│ │ │ │ @@ -346,15 +346,15 @@
│ │ │ │      let ptr = alloc(Layout::new::<i32>()) as *mut i32;
│ │ │ │      // In general .write is required to avoid attempting to destruct
│ │ │ │      // the (uninitialized) previous contents of `ptr`, though for this
│ │ │ │      // simple example `*ptr = 5` would have worked as well.
│ │ │ │      ptr.write(5);
│ │ │ │      let x = Box::from_raw(ptr);
│ │ │ │  }
    Run
    │ │ │ │ -
    source§

    impl<T: ?Sized, A: Allocator> Box<T, A>

    const: unstable · source

    pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Self

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a box from a raw pointer in the given allocator.

    │ │ │ │ +
    source§

    impl<T: ?Sized, A: Allocator> Box<T, A>

    const: unstable · source

    pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Self

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a box from a raw pointer in the given allocator.

    │ │ │ │

    After calling this function, the raw pointer is owned by the │ │ │ │ resulting Box. Specifically, the Box destructor will call │ │ │ │ the destructor of T and free the allocated memory. For this │ │ │ │ to be safe, the memory must have been allocated in accordance │ │ │ │ with the memory layout used by Box .

    │ │ │ │
    §Safety
    │ │ │ │

    This function is unsafe because improper use may lead to │ │ │ │ @@ -381,15 +381,15 @@ │ │ │ │ let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32; │ │ │ │ // In general .write is required to avoid attempting to destruct │ │ │ │ // the (uninitialized) previous contents of `ptr`, though for this │ │ │ │ // simple example `*ptr = 5` would have worked as well. │ │ │ │ ptr.write(5); │ │ │ │ let x = Box::from_raw_in(ptr, System); │ │ │ │ }Run

    │ │ │ │ -
    1.4.0 · source

    pub fn into_raw(b: Self) -> *mut T

    Consumes the Box, returning a wrapped raw pointer.

    │ │ │ │ +
    1.4.0 · source

    pub fn into_raw(b: Self) -> *mut T

    Consumes the Box, returning a wrapped raw pointer.

    │ │ │ │

    The pointer will be properly aligned and non-null.

    │ │ │ │

    After calling this function, the caller is responsible for the │ │ │ │ memory previously managed by the Box. In particular, the │ │ │ │ caller should properly destroy T and release the memory, taking │ │ │ │ into account the memory layout used by Box. The easiest way to │ │ │ │ do this is to convert the raw pointer back into a Box with the │ │ │ │ Box::from_raw function, allowing the Box destructor to perform │ │ │ │ @@ -419,15 +419,15 @@ │ │ │ │

    Note: This is equivalent to the following:

    │ │ │ │ │ │ │ │ 
    let x = Box::new(String::from("Hello"));
│ │ │ │  let ptr = Box::into_raw(x);
│ │ │ │  unsafe {
│ │ │ │      drop(Box::from_raw(ptr));
│ │ │ │  }
    Run
    │ │ │ │ -
    source

    pub fn into_raw_with_allocator(b: Self) -> (*mut T, A)

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Consumes the Box, returning a wrapped raw pointer and the allocator.

    │ │ │ │ +
    source

    pub fn into_raw_with_allocator(b: Self) -> (*mut T, A)

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Consumes the Box, returning a wrapped raw pointer and the allocator.

    │ │ │ │

    The pointer will be properly aligned and non-null.

    │ │ │ │

    After calling this function, the caller is responsible for the │ │ │ │ memory previously managed by the Box. In particular, the │ │ │ │ caller should properly destroy T and release the memory, taking │ │ │ │ into account the memory layout used by Box. The easiest way to │ │ │ │ do this is to convert the raw pointer back into a Box with the │ │ │ │ Box::from_raw_in function, allowing the Box destructor to perform │ │ │ │ @@ -457,19 +457,19 @@ │ │ │ │ let x = Box::new_in(String::from("Hello"), System); │ │ │ │ let (ptr, alloc) = Box::into_raw_with_allocator(x); │ │ │ │ unsafe { │ │ │ │ ptr::drop_in_place(ptr); │ │ │ │ let non_null = NonNull::new_unchecked(ptr); │ │ │ │ alloc.deallocate(non_null.cast(), Layout::new::<String>()); │ │ │ │ }Run

    │ │ │ │ -
    const: unstable · source

    pub fn allocator(b: &Self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ +
    const: unstable · source

    pub fn allocator(b: &Self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │

    Note: this is an associated function, which means that you have │ │ │ │ to call it as Box::allocator(&b) instead of b.allocator(). This │ │ │ │ is so that there is no conflict with a method on the inner type.

    │ │ │ │ -
    1.26.0 · source

    pub fn leak<'a>(b: Self) -> &'a mut T
    where │ │ │ │ +

    1.26.0 · source

    pub fn leak<'a>(b: Self) -> &'a mut T
    where │ │ │ │ A: 'a,

    Consumes and leaks the Box, returning a mutable reference, │ │ │ │ &'a mut T. Note that the type T must outlive the chosen lifetime │ │ │ │ 'a. If the type has only static references, or none at all, then this │ │ │ │ may be chosen to be 'static.

    │ │ │ │

    This function is mainly useful for data that lives for the remainder of │ │ │ │ the program’s life. Dropping the returned reference will cause a memory │ │ │ │ leak. If this is not acceptable, the reference should first be wrapped │ │ │ │ @@ -488,19 +488,19 @@ │ │ │ │ assert_eq!(*static_ref, 42);Run

    │ │ │ │

    Unsized data:

    │ │ │ │ │ │ │ │ 
    let x = vec![1, 2, 3].into_boxed_slice();
│ │ │ │  let static_ref = Box::leak(x);
│ │ │ │  static_ref[0] = 4;
│ │ │ │  assert_eq!(*static_ref, [4, 2, 3]);
    Run
    │ │ │ │ -
    1.63.0 (const: unstable) · source

    pub fn into_pin(boxed: Self) -> Pin<Self>
    where │ │ │ │ - A: 'static,

    Converts a Box<T> into a Pin<Box<T>>. If T does not implement Unpin, then │ │ │ │ +

    1.63.0 (const: unstable) · source

    pub fn into_pin(boxed: Self) -> Pin<Self>
    where │ │ │ │ + A: 'static,

    Converts a Box<T> into a Pin<Box<T>>. If T does not implement Unpin, then │ │ │ │ *boxed will be pinned in memory and unable to be moved.

    │ │ │ │

    This conversion does not allocate on the heap and happens in place.

    │ │ │ │ -

    This is also available via From.

    │ │ │ │ +

    This is also available via From.

    │ │ │ │

    Constructing and pinning a Box with Box::into_pin(Box::new(x)) │ │ │ │ can also be written more concisely using Box::pin(x). │ │ │ │ This into_pin method is useful if you already have a Box<T>, or you are │ │ │ │ constructing a (pinned) Box in a different way than with Box::new.

    │ │ │ │
    §Notes
    │ │ │ │

    It’s not recommended that crates add an impl like From<Box<T>> for Pin<T>, │ │ │ │ as it’ll introduce an ambiguity when calling Pin::from. │ │ │ │ @@ -511,283 +511,283 @@ │ │ │ │ fn from(_: Box<()>) -> Pin<Foo> { │ │ │ │ Pin::new(Foo) │ │ │ │ } │ │ │ │ } │ │ │ │ │ │ │ │ let foo = Box::new(()); │ │ │ │ let bar = Pin::from(foo);Run

    │ │ │ │ -
    source§

    impl<A: Allocator> Box<dyn Any, A>

    source

    pub fn downcast<T: Any>(self) -> Result<Box<T, A>, Self>

    Attempt to downcast the box to a concrete type.

    │ │ │ │ +
    source§

    impl<A: Allocator> Box<dyn Any, A>

    source

    pub fn downcast<T: Any>(self) -> Result<Box<T, A>, Self>

    Attempt to downcast the box to a concrete type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::any::Any;
│ │ │ │  
│ │ │ │  fn print_if_string(value: Box<dyn Any>) {
│ │ │ │      if let Ok(string) = value.downcast::<String>() {
│ │ │ │          println!("String ({}): {}", string.len(), string);
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  let my_string = "Hello World".to_string();
│ │ │ │  print_if_string(Box::new(my_string));
│ │ │ │  print_if_string(Box::new(0i8));
    Run
    │ │ │ │ -
    source

    pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A>

    🔬This is a nightly-only experimental API. (downcast_unchecked #90850)

    Downcasts the box to a concrete type.

    │ │ │ │ +
    source

    pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A>

    🔬This is a nightly-only experimental API. (downcast_unchecked #90850)

    Downcasts the box to a concrete type.

    │ │ │ │

    For a safe alternative see downcast.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(downcast_unchecked)]
│ │ │ │  
│ │ │ │  use std::any::Any;
│ │ │ │  
│ │ │ │  let x: Box<dyn Any> = Box::new(1_usize);
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      assert_eq!(*x.downcast_unchecked::<usize>(), 1);
│ │ │ │  }
    Run
    │ │ │ │
    §Safety
    │ │ │ │

    The contained value must be of type T. Calling this method │ │ │ │ with the incorrect type is undefined behavior.

    │ │ │ │ -
    source§

    impl<A: Allocator> Box<dyn Any + Send, A>

    source

    pub fn downcast<T: Any>(self) -> Result<Box<T, A>, Self>

    Attempt to downcast the box to a concrete type.

    │ │ │ │ +
    source§

    impl<A: Allocator> Box<dyn Any + Send, A>

    source

    pub fn downcast<T: Any>(self) -> Result<Box<T, A>, Self>

    Attempt to downcast the box to a concrete type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::any::Any;
│ │ │ │  
│ │ │ │  fn print_if_string(value: Box<dyn Any + Send>) {
│ │ │ │      if let Ok(string) = value.downcast::<String>() {
│ │ │ │          println!("String ({}): {}", string.len(), string);
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  let my_string = "Hello World".to_string();
│ │ │ │  print_if_string(Box::new(my_string));
│ │ │ │  print_if_string(Box::new(0i8));
    Run
    │ │ │ │ -
    source

    pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A>

    🔬This is a nightly-only experimental API. (downcast_unchecked #90850)

    Downcasts the box to a concrete type.

    │ │ │ │ +
    source

    pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A>

    🔬This is a nightly-only experimental API. (downcast_unchecked #90850)

    Downcasts the box to a concrete type.

    │ │ │ │

    For a safe alternative see downcast.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(downcast_unchecked)]
│ │ │ │  
│ │ │ │  use std::any::Any;
│ │ │ │  
│ │ │ │  let x: Box<dyn Any + Send> = Box::new(1_usize);
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      assert_eq!(*x.downcast_unchecked::<usize>(), 1);
│ │ │ │  }
    Run
    │ │ │ │
    §Safety
    │ │ │ │

    The contained value must be of type T. Calling this method │ │ │ │ with the incorrect type is undefined behavior.

    │ │ │ │ -
    source§

    impl<A: Allocator> Box<dyn Any + Send + Sync, A>

    1.51.0 · source

    pub fn downcast<T: Any>(self) -> Result<Box<T, A>, Self>

    Attempt to downcast the box to a concrete type.

    │ │ │ │ +
    source§

    impl<A: Allocator> Box<dyn Any + Send + Sync, A>

    1.51.0 · source

    pub fn downcast<T: Any>(self) -> Result<Box<T, A>, Self>

    Attempt to downcast the box to a concrete type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::any::Any;
│ │ │ │  
│ │ │ │  fn print_if_string(value: Box<dyn Any + Send + Sync>) {
│ │ │ │      if let Ok(string) = value.downcast::<String>() {
│ │ │ │          println!("String ({}): {}", string.len(), string);
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  let my_string = "Hello World".to_string();
│ │ │ │  print_if_string(Box::new(my_string));
│ │ │ │  print_if_string(Box::new(0i8));
    Run
    │ │ │ │ -
    source

    pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A>

    🔬This is a nightly-only experimental API. (downcast_unchecked #90850)

    Downcasts the box to a concrete type.

    │ │ │ │ +
    source

    pub unsafe fn downcast_unchecked<T: Any>(self) -> Box<T, A>

    🔬This is a nightly-only experimental API. (downcast_unchecked #90850)

    Downcasts the box to a concrete type.

    │ │ │ │

    For a safe alternative see downcast.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(downcast_unchecked)]
│ │ │ │  
│ │ │ │  use std::any::Any;
│ │ │ │  
│ │ │ │  let x: Box<dyn Any + Send + Sync> = Box::new(1_usize);
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      assert_eq!(*x.downcast_unchecked::<usize>(), 1);
│ │ │ │  }
    Run
    │ │ │ │
    §Safety
    │ │ │ │

    The contained value must be of type T. Calling this method │ │ │ │ with the incorrect type is undefined behavior.

    │ │ │ │ -

    Trait Implementations§

    1.5.0 · source§

    impl<T: ?Sized, A: Allocator> AsMut<T> for Box<T, A>

    source§

    fn as_mut(&mut self) -> &mut T

    Converts this type into a mutable reference of the (usually inferred) input type.
    1.5.0 · source§

    impl<T: ?Sized, A: Allocator> AsRef<T> for Box<T, A>

    source§

    fn as_ref(&self) -> &T

    Converts this type into a shared reference of the (usually inferred) input type.
    source§

    impl<Args: Tuple, F: AsyncFn<Args> + ?Sized, A: Allocator> AsyncFn<Args> for Box<F, A>

    §

    type CallFuture<'a> = <F as AsyncFn<Args>>::CallFuture<'a> │ │ │ │ +

    Trait Implementations§

    1.5.0 · source§

    impl<T: ?Sized, A: Allocator> AsMut<T> for Box<T, A>

    source§

    fn as_mut(&mut self) -> &mut T

    Converts this type into a mutable reference of the (usually inferred) input type.
    1.5.0 · source§

    impl<T: ?Sized, A: Allocator> AsRef<T> for Box<T, A>

    source§

    fn as_ref(&self) -> &T

    Converts this type into a shared reference of the (usually inferred) input type.
    source§

    impl<Args: Tuple, F: AsyncFn<Args> + ?Sized, A: Allocator> AsyncFn<Args> for Box<F, A>

    §

    type CallFuture<'a> = <F as AsyncFn<Args>>::CallFuture<'a> │ │ │ │ where │ │ │ │ - Self: 'a

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Future returned by AsyncFn::async_call.
    source§

    extern "rust-call" fn async_call( │ │ │ │ + Self: 'a

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Future returned by AsyncFn::async_call.
    source§

    extern "rust-call" fn async_call( │ │ │ │ &self, │ │ │ │ args: Args │ │ │ │ -) -> Self::CallFuture<'_>

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Call the AsyncFn, returning a future which may borrow from the called closure.
    source§

    impl<Args: Tuple, F: AsyncFnMut<Args> + ?Sized, A: Allocator> AsyncFnMut<Args> for Box<F, A>

    §

    type CallMutFuture<'a> = <F as AsyncFnMut<Args>>::CallMutFuture<'a> │ │ │ │ +) -> Self::CallFuture<'_>

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Call the AsyncFn, returning a future which may borrow from the called closure.
    source§

    impl<Args: Tuple, F: AsyncFnMut<Args> + ?Sized, A: Allocator> AsyncFnMut<Args> for Box<F, A>

    §

    type CallMutFuture<'a> = <F as AsyncFnMut<Args>>::CallMutFuture<'a> │ │ │ │ where │ │ │ │ - Self: 'a

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Future returned by AsyncFnMut::async_call_mut.
    source§

    extern "rust-call" fn async_call_mut( │ │ │ │ + Self: 'a

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Future returned by AsyncFnMut::async_call_mut.
    source§

    extern "rust-call" fn async_call_mut( │ │ │ │ &mut self, │ │ │ │ args: Args │ │ │ │ -) -> Self::CallMutFuture<'_>

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Call the AsyncFnMut, returning a future which may borrow from the called closure.
    source§

    impl<Args: Tuple, F: AsyncFnOnce<Args> + ?Sized, A: Allocator> AsyncFnOnce<Args> for Box<F, A>

    §

    type Output = <F as AsyncFnOnce<Args>>::Output

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Output type of the called closure’s future.
    §

    type CallOnceFuture = <F as AsyncFnOnce<Args>>::CallOnceFuture

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Future returned by AsyncFnOnce::async_call_once.
    source§

    extern "rust-call" fn async_call_once( │ │ │ │ +) -> Self::CallMutFuture<'_>

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Call the AsyncFnMut, returning a future which may borrow from the called closure.
    source§

    impl<Args: Tuple, F: AsyncFnOnce<Args> + ?Sized, A: Allocator> AsyncFnOnce<Args> for Box<F, A>

    §

    type Output = <F as AsyncFnOnce<Args>>::Output

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Output type of the called closure’s future.
    §

    type CallOnceFuture = <F as AsyncFnOnce<Args>>::CallOnceFuture

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Future returned by AsyncFnOnce::async_call_once.
    source§

    extern "rust-call" fn async_call_once( │ │ │ │ self, │ │ │ │ args: Args │ │ │ │ -) -> Self::CallOnceFuture

    🔬This is a nightly-only experimental API. (async_fn_traits)
    Call the AsyncFnOnce, returning a future which may move out of the called closure.
    source§

    impl<S: ?Sized + AsyncIterator + Unpin> AsyncIterator for Box<S>

    §

    type Item = <S as AsyncIterator>::Item

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    The type of items yielded by the async iterator.
    source§

    fn poll_next( │ │ │ │ - self: Pin<&mut Self>, │ │ │ │ - cx: &mut Context<'_> │ │ │ │ -) -> Poll<Option<Self::Item>>

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    Attempt to pull out the next value of this async iterator, registering the │ │ │ │ +) -> Self::CallOnceFuture
    🔬This is a nightly-only experimental API. (async_fn_traits)
    Call the AsyncFnOnce, returning a future which may move out of the called closure.
    source§

    impl<S: ?Sized + AsyncIterator + Unpin> AsyncIterator for Box<S>

    §

    type Item = <S as AsyncIterator>::Item

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    The type of items yielded by the async iterator.
    source§

    fn poll_next( │ │ │ │ + self: Pin<&mut Self>, │ │ │ │ + cx: &mut Context<'_> │ │ │ │ +) -> Poll<Option<Self::Item>>

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    Attempt to pull out the next value of this async iterator, registering the │ │ │ │ current task for wakeup if the value is not yet available, and returning │ │ │ │ -None if the async iterator is exhausted. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    Returns the bounds on the remaining length of the async iterator. Read more
    1.1.0 · source§

    impl<T: ?Sized, A: Allocator> Borrow<T> for Box<T, A>

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    1.1.0 · source§

    impl<T: ?Sized, A: Allocator> BorrowMut<T> for Box<T, A>

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    1.3.0 · source§

    impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, other: &Self)

    Performs copy-assignment from source. Read more
    1.29.0 · source§

    impl Clone for Box<CStr>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Clone, A: Allocator + Clone> Clone for Box<T, A>

    source§

    fn clone(&self) -> Self

    Returns a new box with a clone() of this box’s contents.

    │ │ │ │ +None if the async iterator is exhausted. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    Returns the bounds on the remaining length of the async iterator. Read more
    1.1.0 · source§

    impl<T: ?Sized, A: Allocator> Borrow<T> for Box<T, A>

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    1.1.0 · source§

    impl<T: ?Sized, A: Allocator> BorrowMut<T> for Box<T, A>

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    1.3.0 · source§

    impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, other: &Self)

    Performs copy-assignment from source. Read more
    1.29.0 · source§

    impl Clone for Box<CStr>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Clone, A: Allocator + Clone> Clone for Box<T, A>

    source§

    fn clone(&self) -> Self

    Returns a new box with a clone() of this box’s contents.

    │ │ │ │
    §Examples
    │ │ │ │ 
    let x = Box::new(5);
│ │ │ │  let y = x.clone();
│ │ │ │  
│ │ │ │  // The value is the same
│ │ │ │  assert_eq!(x, y);
│ │ │ │  
│ │ │ │  // But they are unique objects
│ │ │ │  assert_ne!(&*x as *const i32, &*y as *const i32);
    Run
    │ │ │ │ -
    source§

    fn clone_from(&mut self, source: &Self)

    Copies source’s contents into self without creating a new allocation.

    │ │ │ │ +
    source§

    fn clone_from(&mut self, source: &Self)

    Copies source’s contents into self without creating a new allocation.

    │ │ │ │
    §Examples
    │ │ │ │ 
    let x = Box::new(5);
│ │ │ │  let mut y = Box::new(10);
│ │ │ │  let yp: *const i32 = &*y;
│ │ │ │  
│ │ │ │  y.clone_from(&x);
│ │ │ │  
│ │ │ │  // The value is the same
│ │ │ │  assert_eq!(x, y);
│ │ │ │  
│ │ │ │  // And no allocation occurred
│ │ │ │  assert_eq!(yp, &*y);
    Run
    │ │ │ │ -
    1.3.0 · source§

    impl Clone for Box<str>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<G: ?Sized + Coroutine<R> + Unpin, R, A: Allocator> Coroutine<R> for Box<G, A>

    §

    type Yield = <G as Coroutine<R>>::Yield

    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    The type of value this coroutine yields. Read more
    §

    type Return = <G as Coroutine<R>>::Return

    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    The type of value this coroutine returns. Read more
    source§

    fn resume( │ │ │ │ - self: Pin<&mut Self>, │ │ │ │ +

    1.3.0 · source§

    impl Clone for Box<str>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<G: ?Sized + Coroutine<R> + Unpin, R, A: Allocator> Coroutine<R> for Box<G, A>

    §

    type Yield = <G as Coroutine<R>>::Yield

    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    The type of value this coroutine yields. Read more
    §

    type Return = <G as Coroutine<R>>::Return

    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    The type of value this coroutine returns. Read more
    source§

    fn resume( │ │ │ │ + self: Pin<&mut Self>, │ │ │ │ arg: R │ │ │ │ -) -> CoroutineState<Self::Yield, Self::Return>

    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    Resumes the execution of this coroutine. Read more
    source§

    impl<G: ?Sized + Coroutine<R>, R, A> Coroutine<R> for Pin<Box<G, A>>
    where │ │ │ │ - A: 'static + Allocator,

    §

    type Yield = <G as Coroutine<R>>::Yield

    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    The type of value this coroutine yields. Read more
    §

    type Return = <G as Coroutine<R>>::Return

    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    The type of value this coroutine returns. Read more
    source§

    fn resume( │ │ │ │ - self: Pin<&mut Self>, │ │ │ │ +) -> CoroutineState<Self::Yield, Self::Return>

    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    Resumes the execution of this coroutine. Read more
    source§

    impl<G: ?Sized + Coroutine<R>, R, A> Coroutine<R> for Pin<Box<G, A>>
    where │ │ │ │ + A: 'static + Allocator,

    §

    type Yield = <G as Coroutine<R>>::Yield

    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    The type of value this coroutine yields. Read more
    §

    type Return = <G as Coroutine<R>>::Return

    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    The type of value this coroutine returns. Read more
    source§

    fn resume( │ │ │ │ + self: Pin<&mut Self>, │ │ │ │ arg: R │ │ │ │ -) -> CoroutineState<Self::Yield, Self::Return>

    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    Resumes the execution of this coroutine. Read more
    source§

    impl<T: Debug + ?Sized, A: Allocator> Debug for Box<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T> Default for Box<[T]>

    source§

    fn default() -> Self

    Returns the “default value” for a type. Read more
    1.17.0 · source§

    impl Default for Box<CStr>

    source§

    fn default() -> Box<CStr>

    Returns the “default value” for a type. Read more
    source§

    impl<T: Default> Default for Box<T>

    source§

    fn default() -> Self

    Creates a Box<T>, with the Default value for T.

    │ │ │ │ -
    1.17.0 · source§

    impl Default for Box<str>

    source§

    fn default() -> Self

    Returns the “default value” for a type. Read more
    source§

    impl<T: ?Sized, A: Allocator> Deref for Box<T, A>

    §

    type Target = T

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &T

    Dereferences the value.
    source§

    impl<T: ?Sized, A: Allocator> DerefMut for Box<T, A>

    source§

    fn deref_mut(&mut self) -> &mut T

    Mutably dereferences the value.
    source§

    impl<T: Display + ?Sized, A: Allocator> Display for Box<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<I: DoubleEndedIterator + ?Sized, A: Allocator> DoubleEndedIterator for Box<I, A>

    source§

    fn next_back(&mut self) -> Option<I::Item>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn nth_back(&mut self, n: usize) -> Option<I::Item>

    Returns the nth element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T: ?Sized, A: Allocator> Drop for Box<T, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.8.0 · source§

    impl<T: Error> Error for Box<T>

    source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    source§

    fn provide<'b>(&'b self, request: &mut Request<'b>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl<I: ExactSizeIterator + ?Sized, A: Allocator> ExactSizeIterator for Box<I, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.45.0 · source§

    impl Extend<Box<str>> for String

    source§

    fn extend<I: IntoIterator<Item = Box<str>>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, item: A)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.35.0 · source§

    impl<Args: Tuple, F: Fn<Args> + ?Sized, A: Allocator> Fn<Args> for Box<F, A>

    source§

    extern "rust-call" fn call(&self, args: Args) -> Self::Output

    🔬This is a nightly-only experimental API. (fn_traits #29625)
    Performs the call operation.
    1.35.0 · source§

    impl<Args: Tuple, F: FnMut<Args> + ?Sized, A: Allocator> FnMut<Args> for Box<F, A>

    source§

    extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output

    🔬This is a nightly-only experimental API. (fn_traits #29625)
    Performs the call operation.
    1.35.0 · source§

    impl<Args: Tuple, F: FnOnce<Args> + ?Sized, A: Allocator> FnOnce<Args> for Box<F, A>

    §

    type Output = <F as FnOnce<Args>>::Output

    The returned type after the call operator is used.
    source§

    extern "rust-call" fn call_once(self, args: Args) -> Self::Output

    🔬This is a nightly-only experimental API. (fn_traits #29625)
    Performs the call operation.
    1.17.0 · source§

    impl<T: Clone> From<&[T]> for Box<[T]>

    source§

    fn from(slice: &[T]) -> Box<[T]>

    Converts a &[T] into a Box<[T]>

    │ │ │ │ +) -> CoroutineState<Self::Yield, Self::Return>
    🔬This is a nightly-only experimental API. (coroutine_trait #43122)
    Resumes the execution of this coroutine. Read more
    source§

    impl<T: Debug + ?Sized, A: Allocator> Debug for Box<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T> Default for Box<[T]>

    source§

    fn default() -> Self

    Returns the “default value” for a type. Read more
    1.17.0 · source§

    impl Default for Box<CStr>

    source§

    fn default() -> Box<CStr>

    Returns the “default value” for a type. Read more
    source§

    impl<T: Default> Default for Box<T>

    source§

    fn default() -> Self

    Creates a Box<T>, with the Default value for T.

    │ │ │ │ +
    1.17.0 · source§

    impl Default for Box<str>

    source§

    fn default() -> Self

    Returns the “default value” for a type. Read more
    source§

    impl<T: ?Sized, A: Allocator> Deref for Box<T, A>

    §

    type Target = T

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &T

    Dereferences the value.
    source§

    impl<T: ?Sized, A: Allocator> DerefMut for Box<T, A>

    source§

    fn deref_mut(&mut self) -> &mut T

    Mutably dereferences the value.
    source§

    impl<T: Display + ?Sized, A: Allocator> Display for Box<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<I: DoubleEndedIterator + ?Sized, A: Allocator> DoubleEndedIterator for Box<I, A>

    source§

    fn next_back(&mut self) -> Option<I::Item>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn nth_back(&mut self, n: usize) -> Option<I::Item>

    Returns the nth element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T: ?Sized, A: Allocator> Drop for Box<T, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.8.0 · source§

    impl<T: Error> Error for Box<T>

    source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    source§

    fn provide<'b>(&'b self, request: &mut Request<'b>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl<I: ExactSizeIterator + ?Sized, A: Allocator> ExactSizeIterator for Box<I, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.45.0 · source§

    impl Extend<Box<str>> for String

    source§

    fn extend<I: IntoIterator<Item = Box<str>>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, item: A)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.35.0 · source§

    impl<Args: Tuple, F: Fn<Args> + ?Sized, A: Allocator> Fn<Args> for Box<F, A>

    source§

    extern "rust-call" fn call(&self, args: Args) -> Self::Output

    🔬This is a nightly-only experimental API. (fn_traits #29625)
    Performs the call operation.
    1.35.0 · source§

    impl<Args: Tuple, F: FnMut<Args> + ?Sized, A: Allocator> FnMut<Args> for Box<F, A>

    source§

    extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output

    🔬This is a nightly-only experimental API. (fn_traits #29625)
    Performs the call operation.
    1.35.0 · source§

    impl<Args: Tuple, F: FnOnce<Args> + ?Sized, A: Allocator> FnOnce<Args> for Box<F, A>

    §

    type Output = <F as FnOnce<Args>>::Output

    The returned type after the call operator is used.
    source§

    extern "rust-call" fn call_once(self, args: Args) -> Self::Output

    🔬This is a nightly-only experimental API. (fn_traits #29625)
    Performs the call operation.
    1.17.0 · source§

    impl<T: Clone> From<&[T]> for Box<[T]>

    source§

    fn from(slice: &[T]) -> Box<[T]>

    Converts a &[T] into a Box<[T]>

    │ │ │ │

    This conversion allocates on the heap │ │ │ │ and performs a copy of slice and its contents.

    │ │ │ │
    §Examples
    │ │ │ │ 
    // create a &[u8] which will be used to create a Box<[u8]>
│ │ │ │  let slice: &[u8] = &[104, 101, 108, 108, 111];
│ │ │ │  let boxed_slice: Box<[u8]> = Box::from(slice);
│ │ │ │  
│ │ │ │  println!("{boxed_slice:?}");
    Run
    │ │ │ │ -
    1.17.0 · source§

    impl From<&CStr> for Box<CStr>

    source§

    fn from(s: &CStr) -> Box<CStr>

    Converts a &CStr into a Box<CStr>, │ │ │ │ +

    1.17.0 · source§

    impl From<&CStr> for Box<CStr>

    source§

    fn from(s: &CStr) -> Box<CStr>

    Converts a &CStr into a Box<CStr>, │ │ │ │ by copying the contents into a newly allocated Box.

    │ │ │ │ -
    1.6.0 · source§

    impl<'a> From<&str> for Box<dyn Error + 'a>

    source§

    fn from(err: &str) -> Box<dyn Error + 'a>

    Converts a str into a box of dyn Error.

    │ │ │ │ +
    1.6.0 · source§

    impl<'a> From<&str> for Box<dyn Error + 'a>

    source§

    fn from(err: &str) -> Box<dyn Error + 'a>

    Converts a str into a box of dyn Error.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::error::Error;
│ │ │ │  use std::mem;
│ │ │ │  
│ │ │ │  let a_str_error = "a str error";
│ │ │ │  let a_boxed_error = Box::<dyn Error>::from(a_str_error);
│ │ │ │  assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
    Run
    │ │ │ │ -
    source§

    impl<'a> From<&str> for Box<dyn Error + Send + Sync + 'a>

    source§

    fn from(err: &str) -> Box<dyn Error + Send + Sync + 'a>

    Converts a str into a box of dyn Error + Send + Sync.

    │ │ │ │ +
    source§

    impl<'a> From<&str> for Box<dyn Error + Send + Sync + 'a>

    source§

    fn from(err: &str) -> Box<dyn Error + Send + Sync + 'a>

    Converts a str into a box of dyn Error + Send + Sync.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::error::Error;
│ │ │ │  use std::mem;
│ │ │ │  
│ │ │ │  let a_str_error = "a str error";
│ │ │ │  let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_str_error);
│ │ │ │  assert!(
│ │ │ │      mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
    Run
    │ │ │ │ -
    1.17.0 · source§

    impl From<&str> for Box<str>

    source§

    fn from(s: &str) -> Box<str>

    Converts a &str into a Box<str>

    │ │ │ │ +
    1.17.0 · source§

    impl From<&str> for Box<str>

    source§

    fn from(s: &str) -> Box<str>

    Converts a &str into a Box<str>

    │ │ │ │

    This conversion allocates on the heap │ │ │ │ and performs a copy of s.

    │ │ │ │
    §Examples
    │ │ │ │ 
    let boxed: Box<str> = Box::from("hello");
│ │ │ │  println!("{boxed}");
    Run
    │ │ │ │ -
    1.45.0 · source§

    impl<T, const N: usize> From<[T; N]> for Box<[T]>

    source§

    fn from(array: [T; N]) -> Box<[T]>

    Converts a [T; N] into a Box<[T]>

    │ │ │ │ +
    1.45.0 · source§

    impl<T, const N: usize> From<[T; N]> for Box<[T]>

    source§

    fn from(array: [T; N]) -> Box<[T]>

    Converts a [T; N] into a Box<[T]>

    │ │ │ │

    This conversion moves the array to newly heap-allocated memory.

    │ │ │ │
    §Examples
    │ │ │ │ 
    let boxed: Box<[u8]> = Box::from([4, 2]);
│ │ │ │  println!("{boxed:?}");
    Run
    │ │ │ │ -
    1.18.0 · source§

    impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A>

    source§

    fn from(s: Box<[T], A>) -> Self

    Convert a boxed slice into a vector by transferring ownership of │ │ │ │ +

    1.18.0 · source§

    impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A>

    source§

    fn from(s: Box<[T], A>) -> Self

    Convert a boxed slice into a vector by transferring ownership of │ │ │ │ the existing heap allocation.

    │ │ │ │
    §Examples
    │ │ │ │ 
    let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
│ │ │ │  assert_eq!(Vec::from(b), vec![1, 2, 3]);
    Run
    │ │ │ │ -
    1.18.0 · source§

    impl From<Box<CStr>> for CString

    source§

    fn from(s: Box<CStr>) -> CString

    Converts a Box<CStr> into a CString without copying or allocating.

    │ │ │ │ -
    1.21.0 · source§

    impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Arc<T, A>

    source§

    fn from(v: Box<T, A>) -> Arc<T, A>

    Move a boxed object to a new, reference-counted allocation.

    │ │ │ │ +
    1.18.0 · source§

    impl From<Box<CStr>> for CString

    source§

    fn from(s: Box<CStr>) -> CString

    Converts a Box<CStr> into a CString without copying or allocating.

    │ │ │ │ +
    1.21.0 · source§

    impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Arc<T, A>

    source§

    fn from(v: Box<T, A>) -> Arc<T, A>

    Move a boxed object to a new, reference-counted allocation.

    │ │ │ │
    §Example
    │ │ │ │ 
    let unique: Box<str> = Box::from("eggplant");
│ │ │ │  let shared: Arc<str> = Arc::from(unique);
│ │ │ │  assert_eq!("eggplant", &shared[..]);
    Run
    │ │ │ │ -
    1.33.0 · source§

    impl<T: ?Sized, A> From<Box<T, A>> for Pin<Box<T, A>>
    where │ │ │ │ - A: 'static + Allocator,

    source§

    fn from(boxed: Box<T, A>) -> Self

    Converts a Box<T> into a Pin<Box<T>>. If T does not implement Unpin, then │ │ │ │ +

    1.33.0 · source§

    impl<T: ?Sized, A> From<Box<T, A>> for Pin<Box<T, A>>
    where │ │ │ │ + A: 'static + Allocator,

    source§

    fn from(boxed: Box<T, A>) -> Self

    Converts a Box<T> into a Pin<Box<T>>. If T does not implement Unpin, then │ │ │ │ *boxed will be pinned in memory and unable to be moved.

    │ │ │ │

    This conversion does not allocate on the heap and happens in place.

    │ │ │ │

    This is also available via Box::into_pin.

    │ │ │ │

    Constructing and pinning a Box with <Pin<Box<T>>>::from(Box::new(x)) │ │ │ │ can also be written more concisely using Box::pin(x). │ │ │ │ This From implementation is useful if you already have a Box<T>, or you are │ │ │ │ constructing a (pinned) Box in a different way than with Box::new.

    │ │ │ │ -
    1.21.0 · source§

    impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Rc<T, A>

    source§

    fn from(v: Box<T, A>) -> Rc<T, A>

    Move a boxed object to a new, reference counted, allocation.

    │ │ │ │ +
    1.21.0 · source§

    impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Rc<T, A>

    source§

    fn from(v: Box<T, A>) -> Rc<T, A>

    Move a boxed object to a new, reference counted, allocation.

    │ │ │ │
    §Example
    │ │ │ │ 
    let original: Box<i32> = Box::new(1);
│ │ │ │  let shared: Rc<i32> = Rc::from(original);
│ │ │ │  assert_eq!(1, *shared);
    Run
    │ │ │ │ -
    1.18.0 · source§

    impl From<Box<str>> for String

    source§

    fn from(s: Box<str>) -> String

    Converts the given boxed str slice to a String. │ │ │ │ +

    1.18.0 · source§

    impl From<Box<str>> for String

    source§

    fn from(s: Box<str>) -> String

    Converts the given boxed str slice to a String. │ │ │ │ It is notable that the str slice is owned.

    │ │ │ │
    §Examples
    │ │ │ │ 
    let s1: String = String::from("hello world");
│ │ │ │  let s2: Box<str> = s1.into_boxed_str();
│ │ │ │  let s3: String = String::from(s2);
│ │ │ │  
│ │ │ │  assert_eq!("hello world", s3)
    Run
    │ │ │ │ -
    1.19.0 · source§

    impl<A: Allocator> From<Box<str, A>> for Box<[u8], A>

    source§

    fn from(s: Box<str, A>) -> Self

    Converts a Box<str> into a Box<[u8]>

    │ │ │ │ +
    1.19.0 · source§

    impl<A: Allocator> From<Box<str, A>> for Box<[u8], A>

    source§

    fn from(s: Box<str, A>) -> Self

    Converts a Box<str> into a Box<[u8]>

    │ │ │ │

    This conversion does not allocate on the heap and happens in place.

    │ │ │ │
    §Examples
    │ │ │ │ 
    // create a Box<str> which will be used to create a Box<[u8]>
│ │ │ │  let boxed: Box<str> = Box::from("hello");
│ │ │ │  let boxed_str: Box<[u8]> = Box::from(boxed);
│ │ │ │  
│ │ │ │  // create a &[u8] which will be used to create a Box<[u8]>
│ │ │ │  let slice: &[u8] = &[104, 101, 108, 108, 111];
│ │ │ │  let boxed_slice = Box::from(slice);
│ │ │ │  
│ │ │ │  assert_eq!(boxed_slice, boxed_str);
    Run
    │ │ │ │ -
    1.20.0 · source§

    impl From<CString> for Box<CStr>

    source§

    fn from(s: CString) -> Box<CStr>

    Converts a CString into a Box<CStr> without copying or allocating.

    │ │ │ │ -
    1.45.0 · source§

    impl<T: Clone> From<Cow<'_, [T]>> for Box<[T]>

    source§

    fn from(cow: Cow<'_, [T]>) -> Box<[T]>

    Converts a Cow<'_, [T]> into a Box<[T]>

    │ │ │ │ +
    1.20.0 · source§

    impl From<CString> for Box<CStr>

    source§

    fn from(s: CString) -> Box<CStr>

    Converts a CString into a Box<CStr> without copying or allocating.

    │ │ │ │ +
    1.45.0 · source§

    impl<T: Clone> From<Cow<'_, [T]>> for Box<[T]>

    source§

    fn from(cow: Cow<'_, [T]>) -> Box<[T]>

    Converts a Cow<'_, [T]> into a Box<[T]>

    │ │ │ │

    When cow is the Cow::Borrowed variant, this │ │ │ │ conversion allocates on the heap and copies the │ │ │ │ underlying slice. Otherwise, it will try to reuse the owned │ │ │ │ Vec’s allocation.

    │ │ │ │ -
    1.45.0 · source§

    impl From<Cow<'_, CStr>> for Box<CStr>

    source§

    fn from(cow: Cow<'_, CStr>) -> Box<CStr>

    Converts a Cow<'a, CStr> into a Box<CStr>, │ │ │ │ +

    1.45.0 · source§

    impl From<Cow<'_, CStr>> for Box<CStr>

    source§

    fn from(cow: Cow<'_, CStr>) -> Box<CStr>

    Converts a Cow<'a, CStr> into a Box<CStr>, │ │ │ │ by copying the contents if they are borrowed.

    │ │ │ │ -
    1.45.0 · source§

    impl From<Cow<'_, str>> for Box<str>

    source§

    fn from(cow: Cow<'_, str>) -> Box<str>

    Converts a Cow<'_, str> into a Box<str>

    │ │ │ │ +
    1.45.0 · source§

    impl From<Cow<'_, str>> for Box<str>

    source§

    fn from(cow: Cow<'_, str>) -> Box<str>

    Converts a Cow<'_, str> into a Box<str>

    │ │ │ │

    When cow is the Cow::Borrowed variant, this │ │ │ │ conversion allocates on the heap and copies the │ │ │ │ underlying str. Otherwise, it will try to reuse the owned │ │ │ │ String’s allocation.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::borrow::Cow;
│ │ │ │  
│ │ │ │  let unboxed = Cow::Borrowed("hello");
│ │ │ │  let boxed: Box<str> = Box::from(unboxed);
│ │ │ │  println!("{boxed}");
    Run
    │ │ │ │ │ │ │ │ 
    let unboxed = Cow::Owned("hello".to_string());
│ │ │ │  let boxed: Box<str> = Box::from(unboxed);
│ │ │ │  println!("{boxed}");
    Run
    │ │ │ │ -
    1.22.0 · source§

    impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a>

    source§

    fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a>

    Converts a Cow into a box of dyn Error.

    │ │ │ │ +
    1.22.0 · source§

    impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a>

    source§

    fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a>

    Converts a Cow into a box of dyn Error.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::error::Error;
│ │ │ │  use std::mem;
│ │ │ │  use std::borrow::Cow;
│ │ │ │  
│ │ │ │  let a_cow_str_error = Cow::from("a str error");
│ │ │ │  let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
│ │ │ │  assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
    Run
    │ │ │ │ -
    1.22.0 · source§

    impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>

    source§

    fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>

    Converts a Cow into a box of dyn Error + Send + Sync.

    │ │ │ │ +
    1.22.0 · source§

    impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>

    source§

    fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>

    Converts a Cow into a box of dyn Error + Send + Sync.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::error::Error;
│ │ │ │  use std::mem;
│ │ │ │  use std::borrow::Cow;
│ │ │ │  
│ │ │ │  let a_cow_str_error = Cow::from("a str error");
│ │ │ │  let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
│ │ │ │  assert!(
│ │ │ │      mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
    Run
    │ │ │ │ -
    source§

    impl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a>

    source§

    fn from(err: E) -> Box<dyn Error + 'a>

    Converts a type of Error into a box of dyn Error.

    │ │ │ │ +
    source§

    impl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a>

    source§

    fn from(err: E) -> Box<dyn Error + 'a>

    Converts a type of Error into a box of dyn Error.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::error::Error;
│ │ │ │  use std::fmt;
│ │ │ │  use std::mem;
│ │ │ │  
│ │ │ │  #[derive(Debug)]
│ │ │ │  struct AnError;
│ │ │ │ @@ -800,16 +800,16 @@
│ │ │ │  
│ │ │ │  impl Error for AnError {}
│ │ │ │  
│ │ │ │  let an_error = AnError;
│ │ │ │  assert!(0 == mem::size_of_val(&an_error));
│ │ │ │  let a_boxed_error = Box::<dyn Error>::from(an_error);
│ │ │ │  assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
    Run
    │ │ │ │ -
    source§

    impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a>

    source§

    fn from(err: E) -> Box<dyn Error + Send + Sync + 'a>

    Converts a type of Error + Send + Sync into a box of │ │ │ │ -dyn Error + Send + Sync.

    │ │ │ │ +
    source§

    impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a>

    source§

    fn from(err: E) -> Box<dyn Error + Send + Sync + 'a>

    Converts a type of Error + Send + Sync into a box of │ │ │ │ +dyn Error + Send + Sync.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::error::Error;
│ │ │ │  use std::fmt;
│ │ │ │  use std::mem;
│ │ │ │  
│ │ │ │  #[derive(Debug)]
│ │ │ │  struct AnError;
│ │ │ │ @@ -827,281 +827,281 @@
│ │ │ │  unsafe impl Sync for AnError {}
│ │ │ │  
│ │ │ │  let an_error = AnError;
│ │ │ │  assert!(0 == mem::size_of_val(&an_error));
│ │ │ │  let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);
│ │ │ │  assert!(
│ │ │ │      mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
    Run
    │ │ │ │ -
    1.6.0 · source§

    impl<'a> From<String> for Box<dyn Error + 'a>

    source§

    fn from(str_err: String) -> Box<dyn Error + 'a>

    Converts a String into a box of dyn Error.

    │ │ │ │ +
    1.6.0 · source§

    impl<'a> From<String> for Box<dyn Error + 'a>

    source§

    fn from(str_err: String) -> Box<dyn Error + 'a>

    Converts a String into a box of dyn Error.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::error::Error;
│ │ │ │  use std::mem;
│ │ │ │  
│ │ │ │  let a_string_error = "a string error".to_string();
│ │ │ │  let a_boxed_error = Box::<dyn Error>::from(a_string_error);
│ │ │ │  assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
    Run
    │ │ │ │ -
    source§

    impl<'a> From<String> for Box<dyn Error + Send + Sync + 'a>

    source§

    fn from(err: String) -> Box<dyn Error + Send + Sync + 'a>

    Converts a String into a box of dyn Error + Send + Sync.

    │ │ │ │ +
    source§

    impl<'a> From<String> for Box<dyn Error + Send + Sync + 'a>

    source§

    fn from(err: String) -> Box<dyn Error + Send + Sync + 'a>

    Converts a String into a box of dyn Error + Send + Sync.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::error::Error;
│ │ │ │  use std::mem;
│ │ │ │  
│ │ │ │  let a_string_error = "a string error".to_string();
│ │ │ │  let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
│ │ │ │  assert!(
│ │ │ │      mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
    Run
    │ │ │ │ -
    1.20.0 · source§

    impl From<String> for Box<str>

    source§

    fn from(s: String) -> Box<str>

    Converts the given String to a boxed str slice that is owned.

    │ │ │ │ +
    1.20.0 · source§

    impl From<String> for Box<str>

    source§

    fn from(s: String) -> Box<str>

    Converts the given String to a boxed str slice that is owned.

    │ │ │ │
    §Examples
    │ │ │ │ 
    let s1: String = String::from("hello world");
│ │ │ │  let s2: Box<str> = Box::from(s1);
│ │ │ │  let s3: String = String::from(s2);
│ │ │ │  
│ │ │ │  assert_eq!("hello world", s3)
    Run
    │ │ │ │ -
    1.6.0 · source§

    impl<T> From<T> for Box<T>

    source§

    fn from(t: T) -> Self

    Converts a T into a Box<T>

    │ │ │ │ +
    1.6.0 · source§

    impl<T> From<T> for Box<T>

    source§

    fn from(t: T) -> Self

    Converts a T into a Box<T>

    │ │ │ │

    The conversion allocates on the heap and moves t │ │ │ │ from the stack into it.

    │ │ │ │
    §Examples
    │ │ │ │ 
    let x = 5;
│ │ │ │  let boxed = Box::new(5);
│ │ │ │  
│ │ │ │  assert_eq!(Box::from(x), boxed);
    Run
    │ │ │ │ -
    1.20.0 · source§

    impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A>

    source§

    fn from(v: Vec<T, A>) -> Self

    Convert a vector into a boxed slice.

    │ │ │ │ +
    1.20.0 · source§

    impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A>

    source§

    fn from(v: Vec<T, A>) -> Self

    Convert a vector into a boxed slice.

    │ │ │ │

    Before doing the conversion, this method discards excess capacity like Vec::shrink_to_fit.

    │ │ │ │
    §Examples
    │ │ │ │ 
    assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());
    Run
    │ │ │ │

    Any excess capacity is removed:

    │ │ │ │ │ │ │ │ 
    let mut vec = Vec::with_capacity(10);
│ │ │ │  vec.extend([1, 2, 3]);
│ │ │ │  
│ │ │ │  assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice());
    Run
    │ │ │ │ -
    1.45.0 · source§

    impl FromIterator<Box<str>> for String

    source§

    fn from_iter<I: IntoIterator<Item = Box<str>>>(iter: I) -> String

    Creates a value from an iterator. Read more
    1.32.0 · source§

    impl<I> FromIterator<I> for Box<[I]>

    source§

    fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self

    Creates a value from an iterator. Read more
    1.36.0 · source§

    impl<F: ?Sized + Future + Unpin, A: Allocator> Future for Box<F, A>

    §

    type Output = <F as Future>::Output

    The type of value produced on completion.
    source§

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

    Attempt to resolve the future to a final value, registering │ │ │ │ -the current task for wakeup if the value is not yet available. Read more
    source§

    impl<T: ?Sized + Hash, A: Allocator> Hash for Box<T, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ - H: Hasher, │ │ │ │ - Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    1.22.0 · source§

    impl<T: ?Sized + Hasher, A: Allocator> Hasher for Box<T, A>

    source§

    fn finish(&self) -> u64

    Returns the hash value for the values written so far. Read more
    source§

    fn write(&mut self, bytes: &[u8])

    Writes some data into this Hasher. Read more
    source§

    fn write_u8(&mut self, i: u8)

    Writes a single u8 into this hasher.
    source§

    fn write_u16(&mut self, i: u16)

    Writes a single u16 into this hasher.
    source§

    fn write_u32(&mut self, i: u32)

    Writes a single u32 into this hasher.
    source§

    fn write_u64(&mut self, i: u64)

    Writes a single u64 into this hasher.
    source§

    fn write_u128(&mut self, i: u128)

    Writes a single u128 into this hasher.
    source§

    fn write_usize(&mut self, i: usize)

    Writes a single usize into this hasher.
    source§

    fn write_i8(&mut self, i: i8)

    Writes a single i8 into this hasher.
    source§

    fn write_i16(&mut self, i: i16)

    Writes a single i16 into this hasher.
    source§

    fn write_i32(&mut self, i: i32)

    Writes a single i32 into this hasher.
    source§

    fn write_i64(&mut self, i: i64)

    Writes a single i64 into this hasher.
    source§

    fn write_i128(&mut self, i: i128)

    Writes a single i128 into this hasher.
    source§

    fn write_isize(&mut self, i: isize)

    Writes a single isize into this hasher.
    source§

    fn write_length_prefix(&mut self, len: usize)

    🔬This is a nightly-only experimental API. (hasher_prefixfree_extras #96762)
    Writes a length prefix into this hasher, as part of being prefix-free. Read more
    source§

    fn write_str(&mut self, s: &str)

    🔬This is a nightly-only experimental API. (hasher_prefixfree_extras #96762)
    Writes a single str into this hasher. Read more
    source§

    impl<I: Iterator + ?Sized, A: Allocator> Iterator for Box<I, A>

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<I::Item>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<I::Item>

    Returns the nth element of the iterator. Read more
    source§

    fn last(self) -> Option<I::Item>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    1.45.0 · source§

    impl FromIterator<Box<str>> for String

    source§

    fn from_iter<I: IntoIterator<Item = Box<str>>>(iter: I) -> String

    Creates a value from an iterator. Read more
    1.32.0 · source§

    impl<I> FromIterator<I> for Box<[I]>

    source§

    fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self

    Creates a value from an iterator. Read more
    1.36.0 · source§

    impl<F: ?Sized + Future + Unpin, A: Allocator> Future for Box<F, A>

    §

    type Output = <F as Future>::Output

    The type of value produced on completion.
    source§

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

    Attempt to resolve the future to a final value, registering │ │ │ │ +the current task for wakeup if the value is not yet available. Read more
    source§

    impl<T: ?Sized + Hash, A: Allocator> Hash for Box<T, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ + H: Hasher, │ │ │ │ + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    1.22.0 · source§

    impl<T: ?Sized + Hasher, A: Allocator> Hasher for Box<T, A>

    source§

    fn finish(&self) -> u64

    Returns the hash value for the values written so far. Read more
    source§

    fn write(&mut self, bytes: &[u8])

    Writes some data into this Hasher. Read more
    source§

    fn write_u8(&mut self, i: u8)

    Writes a single u8 into this hasher.
    source§

    fn write_u16(&mut self, i: u16)

    Writes a single u16 into this hasher.
    source§

    fn write_u32(&mut self, i: u32)

    Writes a single u32 into this hasher.
    source§

    fn write_u64(&mut self, i: u64)

    Writes a single u64 into this hasher.
    source§

    fn write_u128(&mut self, i: u128)

    Writes a single u128 into this hasher.
    source§

    fn write_usize(&mut self, i: usize)

    Writes a single usize into this hasher.
    source§

    fn write_i8(&mut self, i: i8)

    Writes a single i8 into this hasher.
    source§

    fn write_i16(&mut self, i: i16)

    Writes a single i16 into this hasher.
    source§

    fn write_i32(&mut self, i: i32)

    Writes a single i32 into this hasher.
    source§

    fn write_i64(&mut self, i: i64)

    Writes a single i64 into this hasher.
    source§

    fn write_i128(&mut self, i: i128)

    Writes a single i128 into this hasher.
    source§

    fn write_isize(&mut self, i: isize)

    Writes a single isize into this hasher.
    source§

    fn write_length_prefix(&mut self, len: usize)

    🔬This is a nightly-only experimental API. (hasher_prefixfree_extras #96762)
    Writes a length prefix into this hasher, as part of being prefix-free. Read more
    source§

    fn write_str(&mut self, s: &str)

    🔬This is a nightly-only experimental API. (hasher_prefixfree_extras #96762)
    Writes a single str into this hasher. Read more
    source§

    impl<I: Iterator + ?Sized, A: Allocator> Iterator for Box<I, A>

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<I::Item>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<I::Item>

    Returns the nth element of the iterator. Read more
    source§

    fn last(self) -> Option<I::Item>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T: ?Sized + Ord, A: Allocator> Ord for Box<T, A>

    source§

    fn cmp(&self, other: &Self) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ - Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Box<T, A>

    source§

    fn eq(&self, other: &Self) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Self) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Box<T, A>

    source§

    fn partial_cmp(&self, other: &Self) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Self) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Self) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ -operator. Read more
    source§

    fn ge(&self, other: &Self) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ -operator. Read more
    source§

    fn gt(&self, other: &Self) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    impl<T: ?Sized, A: Allocator> Pointer for Box<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    1.43.0 · source§

    impl<T, const N: usize> TryFrom<Box<[T]>> for Box<[T; N]>

    source§

    fn try_from(boxed_slice: Box<[T]>) -> Result<Self, Self::Error>

    Attempts to convert a Box<[T]> into a Box<[T; N]>.

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T: ?Sized + Ord, A: Allocator> Ord for Box<T, A>

    source§

    fn cmp(&self, other: &Self) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ + Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Box<T, A>

    source§

    fn eq(&self, other: &Self) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Self) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Box<T, A>

    source§

    fn partial_cmp(&self, other: &Self) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Self) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Self) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ +operator. Read more
    source§

    fn ge(&self, other: &Self) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ +operator. Read more
    source§

    fn gt(&self, other: &Self) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    impl<T: ?Sized, A: Allocator> Pointer for Box<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    1.43.0 · source§

    impl<T, const N: usize> TryFrom<Box<[T]>> for Box<[T; N]>

    source§

    fn try_from(boxed_slice: Box<[T]>) -> Result<Self, Self::Error>

    Attempts to convert a Box<[T]> into a Box<[T; N]>.

    │ │ │ │

    The conversion occurs in-place and does not require a │ │ │ │ new memory allocation.

    │ │ │ │
    §Errors
    │ │ │ │

    Returns the old Box<[T]> in the Err variant if │ │ │ │ boxed_slice.len() does not equal N.

    │ │ │ │ -
    §

    type Error = Box<[T]>

    The type returned in the event of a conversion error.
    1.66.0 · source§

    impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]>

    source§

    fn try_from(vec: Vec<T>) -> Result<Self, Self::Error>

    Attempts to convert a Vec<T> into a Box<[T; N]>.

    │ │ │ │ +
    §

    type Error = Box<[T]>

    The type returned in the event of a conversion error.
    1.66.0 · source§

    impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]>

    source§

    fn try_from(vec: Vec<T>) -> Result<Self, Self::Error>

    Attempts to convert a Vec<T> into a Box<[T; N]>.

    │ │ │ │

    Like Vec::into_boxed_slice, this is in-place if vec.capacity() == N, │ │ │ │ but will require a reallocation otherwise.

    │ │ │ │
    §Errors
    │ │ │ │

    Returns the original Vec<T> in the Err variant if │ │ │ │ boxed_slice.len() does not equal N.

    │ │ │ │
    §Examples
    │ │ │ │

    This can be used with vec! to create an array on the heap:

    │ │ │ │ │ │ │ │ 
    let state: Box<[f32; 100]> = vec![1.0; 100].try_into().unwrap();
│ │ │ │  assert_eq!(state.len(), 100);
    Run
    │ │ │ │ -
    §

    type Error = Vec<T>

    The type returned in the event of a conversion error.
    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Box<U, A>> for Box<T, A>

    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Box<U>> for Box<T, Global>

    source§

    impl<T: ?Sized + Eq, A: Allocator> Eq for Box<T, A>

    1.26.0 · source§

    impl<I: FusedIterator + ?Sized, A: Allocator> FusedIterator for Box<I, A>

    1.33.0 · source§

    impl<T: ?Sized, A: Allocator> Unpin for Box<T, A>

    Auto Trait Implementations§

    §

    impl<T: ?Sized, A> Freeze for Box<T, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<T: ?Sized, A> RefUnwindSafe for Box<T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<T: ?Sized, A> Send for Box<T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<T: ?Sized, A> Sync for Box<T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<T: ?Sized, A> UnwindSafe for Box<T, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<!> for T

    source§

    fn from(t: !) -> T

    Converts to this type from the input type.
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +
    §

    type Error = Vec<T>

    The type returned in the event of a conversion error.
    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Box<U, A>> for Box<T, A>

    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Box<U>> for Box<T, Global>

    source§

    impl<T: ?Sized + Eq, A: Allocator> Eq for Box<T, A>

    1.26.0 · source§

    impl<I: FusedIterator + ?Sized, A: Allocator> FusedIterator for Box<I, A>

    1.33.0 · source§

    impl<T: ?Sized, A: Allocator> Unpin for Box<T, A>

    Auto Trait Implementations§

    §

    impl<T: ?Sized, A> Freeze for Box<T, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<T: ?Sized, A> RefUnwindSafe for Box<T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<T: ?Sized, A> Send for Box<T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<T: ?Sized, A> Sync for Box<T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<T: ?Sized, A> UnwindSafe for Box<T, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<!> for T

    source§

    fn from(t: !) -> T

    Converts to this type from the input type.
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoAsyncIterator for I
    where │ │ │ │ - I: AsyncIterator,

    §

    type Item = <I as AsyncIterator>::Item

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    The type of the item yielded by the iterator
    §

    type IntoAsyncIter = I

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    The type of the resulting iterator
    source§

    fn into_async_iter(self) -> <I as IntoAsyncIterator>::IntoAsyncIter

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    Converts self into an async iterator
    source§

    impl<F> IntoFuture for F
    where │ │ │ │ - F: Future,

    §

    type Output = <F as Future>::Output

    The output that the future will produce on completion.
    §

    type IntoFuture = F

    Which kind of future are we turning this into?
    source§

    fn into_future(self) -> <F as IntoFuture>::IntoFuture

    Creates a future from a value. Read more
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<'a, F> Pattern<'a> for F
    where │ │ │ │ - F: FnMut(char) -> bool,

    §

    type Searcher = CharPredicateSearcher<'a, F>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Associated searcher for this pattern
    source§

    fn into_searcher(self, haystack: &'a str) -> CharPredicateSearcher<'a, F>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Constructs the associated searcher from │ │ │ │ -self and the haystack to search in.
    source§

    fn is_contained_in(self, haystack: &'a str) -> bool

    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches anywhere in the haystack
    source§

    fn is_prefix_of(self, haystack: &'a str) -> bool

    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches at the front of the haystack
    source§

    fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Removes the pattern from the front of haystack, if it matches.
    source§

    fn is_suffix_of(self, haystack: &'a str) -> bool
    where │ │ │ │ - CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,

    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches at the back of the haystack
    source§

    fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
    where │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +

    source§

    impl<I> IntoAsyncIterator for I
    where │ │ │ │ + I: AsyncIterator,

    §

    type Item = <I as AsyncIterator>::Item

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    The type of the item yielded by the iterator
    §

    type IntoAsyncIter = I

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    The type of the resulting iterator
    source§

    fn into_async_iter(self) -> <I as IntoAsyncIterator>::IntoAsyncIter

    🔬This is a nightly-only experimental API. (async_iterator #79024)
    Converts self into an async iterator
    source§

    impl<F> IntoFuture for F
    where │ │ │ │ + F: Future,

    §

    type Output = <F as Future>::Output

    The output that the future will produce on completion.
    §

    type IntoFuture = F

    Which kind of future are we turning this into?
    source§

    fn into_future(self) -> <F as IntoFuture>::IntoFuture

    Creates a future from a value. Read more
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<'a, F> Pattern<'a> for F
    where │ │ │ │ + F: FnMut(char) -> bool,

    §

    type Searcher = CharPredicateSearcher<'a, F>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Associated searcher for this pattern
    source§

    fn into_searcher(self, haystack: &'a str) -> CharPredicateSearcher<'a, F>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Constructs the associated searcher from │ │ │ │ +self and the haystack to search in.
    source§

    fn is_contained_in(self, haystack: &'a str) -> bool

    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches anywhere in the haystack
    source§

    fn is_prefix_of(self, haystack: &'a str) -> bool

    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches at the front of the haystack
    source§

    fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Removes the pattern from the front of haystack, if it matches.
    source§

    fn is_suffix_of(self, haystack: &'a str) -> bool
    where │ │ │ │ + CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,

    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches at the back of the haystack
    source§

    fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
    where │ │ │ │ CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,

    🔬This is a nightly-only experimental API. (pattern #27721)
    Removes the pattern from the back of haystack, if it matches.
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/boxed/struct.ThinBox.html │ │ │ │ @@ -1,54 +1,54 @@ │ │ │ │ ThinBox in alloc::boxed - Rust
    │ │ │ │ -

    Struct alloc::boxed::ThinBox

    source · 
    pub struct ThinBox<T: ?Sized> { /* private fields */ }
    🔬This is a nightly-only experimental API. (thin_box #92791)
    Expand description

    ThinBox.

    │ │ │ │ +

    Struct alloc::boxed::ThinBox

    source · 
    pub struct ThinBox<T: ?Sized> { /* private fields */ }
    🔬This is a nightly-only experimental API. (thin_box #92791)
    Expand description

    ThinBox.

    │ │ │ │

    A thin pointer for heap allocation, regardless of T.

    │ │ │ │

    §Examples

    │ │ │ │ 
    #![feature(thin_box)]
│ │ │ │  use std::boxed::ThinBox;
│ │ │ │  
│ │ │ │  let five = ThinBox::new(5);
│ │ │ │  let thin_slice = ThinBox::<[i32]>::new_unsize([1, 2, 3, 4]);
│ │ │ │  
│ │ │ │  use std::mem::{size_of, size_of_val};
│ │ │ │  let size_of_ptr = size_of::<*const ()>();
│ │ │ │  assert_eq!(size_of_ptr, size_of_val(&five));
│ │ │ │  assert_eq!(size_of_ptr, size_of_val(&thin_slice));
    Run
    │ │ │ │ -

    Implementations§

    source§

    impl<T> ThinBox<T>

    source

    pub fn new(value: T) -> Self

    🔬This is a nightly-only experimental API. (thin_box #92791)

    Moves a type to the heap with its Metadata stored in the heap allocation instead of on │ │ │ │ +

    Implementations§

    source§

    impl<T> ThinBox<T>

    source

    pub fn new(value: T) -> Self

    🔬This is a nightly-only experimental API. (thin_box #92791)

    Moves a type to the heap with its Metadata stored in the heap allocation instead of on │ │ │ │ the stack.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(thin_box)]
│ │ │ │  use std::boxed::ThinBox;
│ │ │ │  
│ │ │ │  let five = ThinBox::new(5);
    Run
    │ │ │ │ -
    source

    pub fn try_new(value: T) -> Result<Self, AllocError>

    🔬This is a nightly-only experimental API. (thin_box #92791)

    Moves a type to the heap with its Metadata stored in the heap allocation instead of on │ │ │ │ +

    source

    pub fn try_new(value: T) -> Result<Self, AllocError>

    🔬This is a nightly-only experimental API. (thin_box #92791)

    Moves a type to the heap with its Metadata stored in the heap allocation instead of on │ │ │ │ the stack. Returns an error if allocation fails, instead of aborting.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(allocator_api)]
│ │ │ │  #![feature(thin_box)]
│ │ │ │  use std::boxed::ThinBox;
│ │ │ │  
│ │ │ │  let five = ThinBox::try_new(5)?;
    Run
    │ │ │ │ -
    source§

    impl<Dyn: ?Sized> ThinBox<Dyn>

    source

    pub fn new_unsize<T>(value: T) -> Self
    where │ │ │ │ - T: Unsize<Dyn>,

    🔬This is a nightly-only experimental API. (thin_box #92791)

    Moves a type to the heap with its Metadata stored in the heap allocation instead of on │ │ │ │ +

    source§

    impl<Dyn: ?Sized> ThinBox<Dyn>

    source

    pub fn new_unsize<T>(value: T) -> Self
    where │ │ │ │ + T: Unsize<Dyn>,

    🔬This is a nightly-only experimental API. (thin_box #92791)

    Moves a type to the heap with its Metadata stored in the heap allocation instead of on │ │ │ │ the stack.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(thin_box)]
│ │ │ │  use std::boxed::ThinBox;
│ │ │ │  
│ │ │ │  let thin_slice = ThinBox::<[i32]>::new_unsize([1, 2, 3, 4]);
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: ?Sized + Debug> Debug for ThinBox<T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: ?Sized> Deref for ThinBox<T>

    §

    type Target = T

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &T

    Dereferences the value.
    source§

    impl<T: ?Sized> DerefMut for ThinBox<T>

    source§

    fn deref_mut(&mut self) -> &mut T

    Mutably dereferences the value.
    source§

    impl<T: ?Sized + Display> Display for ThinBox<T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: ?Sized> Drop for ThinBox<T>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    source§

    impl<T: ?Sized + Error> Error for ThinBox<T>

    source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl<T: ?Sized + Send> Send for ThinBox<T>

    ThinBox<T> is Send if T is Send because the data is owned.

    │ │ │ │ -
    source§

    impl<T: ?Sized + Sync> Sync for ThinBox<T>

    ThinBox<T> is Sync if T is Sync because the data is owned.

    │ │ │ │ -

    Auto Trait Implementations§

    §

    impl<T: ?Sized> Freeze for ThinBox<T>

    §

    impl<T: ?Sized> RefUnwindSafe for ThinBox<T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<T: ?Sized> Unpin for ThinBox<T>
    where │ │ │ │ - T: Unpin,

    §

    impl<T: ?Sized> UnwindSafe for ThinBox<T>
    where │ │ │ │ - T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: ?Sized + Debug> Debug for ThinBox<T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: ?Sized> Deref for ThinBox<T>

    §

    type Target = T

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &T

    Dereferences the value.
    source§

    impl<T: ?Sized> DerefMut for ThinBox<T>

    source§

    fn deref_mut(&mut self) -> &mut T

    Mutably dereferences the value.
    source§

    impl<T: ?Sized + Display> Display for ThinBox<T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: ?Sized> Drop for ThinBox<T>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    source§

    impl<T: ?Sized + Error> Error for ThinBox<T>

    source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl<T: ?Sized + Send> Send for ThinBox<T>

    ThinBox<T> is Send if T is Send because the data is owned.

    │ │ │ │ +
    source§

    impl<T: ?Sized + Sync> Sync for ThinBox<T>

    ThinBox<T> is Sync if T is Sync because the data is owned.

    │ │ │ │ +

    Auto Trait Implementations§

    §

    impl<T: ?Sized> Freeze for ThinBox<T>

    §

    impl<T: ?Sized> RefUnwindSafe for ThinBox<T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<T: ?Sized> Unpin for ThinBox<T>
    where │ │ │ │ + T: Unpin,

    §

    impl<T: ?Sized> UnwindSafe for ThinBox<T>
    where │ │ │ │ + T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Display + ?Sized,
    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.BinaryHeap.html │ │ │ │ @@ -1,12 +1,12 @@ │ │ │ │ BinaryHeap in alloc::collections::binary_heap - Rust
    │ │ │ │

    Struct alloc::collections::binary_heap::BinaryHeap

    1.0.0 · source · 
    pub struct BinaryHeap<T, A: Allocator = Global> { /* private fields */ }
    Expand description

    A priority queue implemented with a binary heap.

    │ │ │ │

    This will be a max-heap.

    │ │ │ │

    It is a logic error for an item to be modified in such a way that the │ │ │ │ -item’s ordering relative to any other item, as determined by the Ord │ │ │ │ +item’s ordering relative to any other item, as determined by the Ord │ │ │ │ trait, changes while it is in the heap. This is normally only possible │ │ │ │ through interior mutability, global state, I/O, or unsafe code. The │ │ │ │ behavior resulting from such a logic error is not specified, but will │ │ │ │ be encapsulated to the BinaryHeap that observed the logic error and not │ │ │ │ result in undefined behavior. This could include panics, incorrect results, │ │ │ │ aborts, memory leaks, and non-termination.

    │ │ │ │

    As long as no elements change their relative order while being in the heap │ │ │ │ @@ -57,15 +57,15 @@ │ │ │ │ assert!(heap.is_empty())Run

    │ │ │ │

    A BinaryHeap with a known list of items can be initialized from an array:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  
│ │ │ │  let heap = BinaryHeap::from([1, 5, 2]);
    Run
    │ │ │ │

    §Min-heap

    │ │ │ │ -

    Either core::cmp::Reverse or a custom Ord implementation can be used to │ │ │ │ +

    Either core::cmp::Reverse or a custom Ord implementation can be used to │ │ │ │ make BinaryHeap a min-heap. This makes heap.pop() return the smallest │ │ │ │ value instead of the greatest one.

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  use std::cmp::Reverse;
│ │ │ │  
│ │ │ │  let mut heap = BinaryHeap::new();
│ │ │ │ @@ -82,55 +82,55 @@
│ │ │ │  assert_eq!(heap.pop(), None);
    Run
    │ │ │ │

    §Time complexity

    │ │ │ │ │ │ │ │
    pushpoppeek/peek_mut
    O(1)~O(log(n))O(1)
    │ │ │ │
    │ │ │ │

    The value for push is an expected cost; the method documentation gives a │ │ │ │ more detailed analysis.

    │ │ │ │ -

    Implementations§

    source§

    impl<T: Ord> BinaryHeap<T>

    const: unstable · source

    pub fn new() -> BinaryHeap<T>

    Creates an empty BinaryHeap as a max-heap.

    │ │ │ │ +

    Implementations§

    source§

    impl<T: Ord> BinaryHeap<T>

    const: unstable · source

    pub fn new() -> BinaryHeap<T>

    Creates an empty BinaryHeap as a max-heap.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  let mut heap = BinaryHeap::new();
│ │ │ │  heap.push(4);
    Run
    │ │ │ │ -
    source

    pub fn with_capacity(capacity: usize) -> BinaryHeap<T>

    Creates an empty BinaryHeap with at least the specified capacity.

    │ │ │ │ +
    source

    pub fn with_capacity(capacity: usize) -> BinaryHeap<T>

    Creates an empty BinaryHeap with at least the specified capacity.

    │ │ │ │

    The binary heap will be able to hold at least capacity elements without │ │ │ │ reallocating. This method is allowed to allocate for more elements than │ │ │ │ capacity. If capacity is 0, the binary heap will not allocate.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  let mut heap = BinaryHeap::with_capacity(10);
│ │ │ │  heap.push(4);
    Run
    │ │ │ │ -
    source§

    impl<T: Ord, A: Allocator> BinaryHeap<T, A>

    const: unstable · source

    pub fn new_in(alloc: A) -> BinaryHeap<T, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Creates an empty BinaryHeap as a max-heap, using A as allocator.

    │ │ │ │ +
    source§

    impl<T: Ord, A: Allocator> BinaryHeap<T, A>

    const: unstable · source

    pub fn new_in(alloc: A) -> BinaryHeap<T, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Creates an empty BinaryHeap as a max-heap, using A as allocator.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  use std::collections::BinaryHeap;
│ │ │ │  let mut heap = BinaryHeap::new_in(System);
│ │ │ │  heap.push(4);
    Run
    │ │ │ │ -
    source

    pub fn with_capacity_in(capacity: usize, alloc: A) -> BinaryHeap<T, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Creates an empty BinaryHeap with at least the specified capacity, using A as allocator.

    │ │ │ │ +
    source

    pub fn with_capacity_in(capacity: usize, alloc: A) -> BinaryHeap<T, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Creates an empty BinaryHeap with at least the specified capacity, using A as allocator.

    │ │ │ │

    The binary heap will be able to hold at least capacity elements without │ │ │ │ reallocating. This method is allowed to allocate for more elements than │ │ │ │ capacity. If capacity is 0, the binary heap will not allocate.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  use std::collections::BinaryHeap;
│ │ │ │  let mut heap = BinaryHeap::with_capacity_in(10, System);
│ │ │ │  heap.push(4);
    Run
    │ │ │ │ -
    1.12.0 · source

    pub fn peek_mut(&mut self) -> Option<PeekMut<'_, T, A>>

    Returns a mutable reference to the greatest item in the binary heap, or │ │ │ │ +

    1.12.0 · source

    pub fn peek_mut(&mut self) -> Option<PeekMut<'_, T, A>>

    Returns a mutable reference to the greatest item in the binary heap, or │ │ │ │ None if it is empty.

    │ │ │ │

    Note: If the PeekMut value is leaked, some heap elements might get │ │ │ │ leaked along with it, but the remaining elements will remain a valid │ │ │ │ heap.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ @@ -145,15 +145,15 @@ │ │ │ │ let mut val = heap.peek_mut().unwrap(); │ │ │ │ *val = 0; │ │ │ │ } │ │ │ │ assert_eq!(heap.peek(), Some(&2));Run
    │ │ │ │
    §Time complexity
    │ │ │ │

    If the item is modified then the worst case time complexity is O(log(n)), │ │ │ │ otherwise it’s O(1).

    │ │ │ │ -
    source

    pub fn pop(&mut self) -> Option<T>

    Removes the greatest item from the binary heap and returns it, or None if it │ │ │ │ +

    source

    pub fn pop(&mut self) -> Option<T>

    Removes the greatest item from the binary heap and returns it, or None if it │ │ │ │ is empty.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  let mut heap = BinaryHeap::from([1, 3]);
│ │ │ │  
│ │ │ │ @@ -195,15 +195,15 @@
│ │ │ │  
│ │ │ │  let mut heap = BinaryHeap::from([1, 2, 4, 5, 7]);
│ │ │ │  heap.push(6);
│ │ │ │  heap.push(3);
│ │ │ │  
│ │ │ │  let vec = heap.into_sorted_vec();
│ │ │ │  assert_eq!(vec, [1, 2, 3, 4, 5, 6, 7]);
    Run
    │ │ │ │ -
    1.11.0 · source

    pub fn append(&mut self, other: &mut Self)

    Moves all the elements of other into self, leaving other empty.

    │ │ │ │ +
    1.11.0 · source

    pub fn append(&mut self, other: &mut Self)

    Moves all the elements of other into self, leaving other empty.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  
│ │ │ │  let mut a = BinaryHeap::from([-10, 1, 2, 3, 3]);
│ │ │ │  let mut b = BinaryHeap::from([-20, 5, 43]);
│ │ │ │ @@ -230,15 +230,15 @@
│ │ │ │  
│ │ │ │  let mut heap = BinaryHeap::from([1, 2, 3, 4, 5]);
│ │ │ │  assert_eq!(heap.len(), 5);
│ │ │ │  
│ │ │ │  drop(heap.drain_sorted()); // removes all elements in heap order
│ │ │ │  assert_eq!(heap.len(), 0);
    Run
    │ │ │ │
    1.70.0 · source

    pub fn retain<F>(&mut self, f: F)
    where │ │ │ │ - F: FnMut(&T) -> bool,

    Retains only the elements specified by the predicate.

    │ │ │ │ + F: FnMut(&T) -> bool,

    Retains only the elements specified by the predicate.

    │ │ │ │

    In other words, remove all elements e for which f(&e) returns │ │ │ │ false. The elements are visited in unsorted (and unspecified) order.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  
│ │ │ │ @@ -265,72 +265,72 @@
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    #![feature(binary_heap_into_iter_sorted)]
│ │ │ │  use std::collections::BinaryHeap;
│ │ │ │  let heap = BinaryHeap::from([1, 2, 3, 4, 5]);
│ │ │ │  
│ │ │ │  assert_eq!(heap.into_iter_sorted().take(2).collect::<Vec<_>>(), [5, 4]);
    Run
    
│ │ │ │ -
    source

    pub fn peek(&self) -> Option<&T>

    Returns the greatest item in the binary heap, or None if it is empty.

    │ │ │ │ +
    source

    pub fn peek(&self) -> Option<&T>

    Returns the greatest item in the binary heap, or None if it is empty.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  let mut heap = BinaryHeap::new();
│ │ │ │  assert_eq!(heap.peek(), None);
│ │ │ │  
│ │ │ │  heap.push(1);
│ │ │ │  heap.push(5);
│ │ │ │  heap.push(2);
│ │ │ │  assert_eq!(heap.peek(), Some(&5));
│ │ │ │
    Run
    │ │ │ │
    §Time complexity
    │ │ │ │

    Cost is O(1) in the worst case.

    │ │ │ │ -
    source

    pub fn capacity(&self) -> usize

    Returns the number of elements the binary heap can hold without reallocating.

    │ │ │ │ +
    source

    pub fn capacity(&self) -> usize

    Returns the number of elements the binary heap can hold without reallocating.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  let mut heap = BinaryHeap::with_capacity(100);
│ │ │ │  assert!(heap.capacity() >= 100);
│ │ │ │  heap.push(4);
    Run
    │ │ │ │ -
    source

    pub fn reserve_exact(&mut self, additional: usize)

    Reserves the minimum capacity for at least additional elements more than │ │ │ │ +

    source

    pub fn reserve_exact(&mut self, additional: usize)

    Reserves the minimum capacity for at least additional elements more than │ │ │ │ the current length. Unlike reserve, this will not │ │ │ │ deliberately over-allocate to speculatively avoid frequent allocations. │ │ │ │ After calling reserve_exact, capacity will be greater than or equal to │ │ │ │ self.len() + additional. Does nothing if the capacity is already │ │ │ │ sufficient.

    │ │ │ │
    §Panics
    │ │ │ │ -

    Panics if the new capacity overflows usize.

    │ │ │ │ +

    Panics if the new capacity overflows usize.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  let mut heap = BinaryHeap::new();
│ │ │ │  heap.reserve_exact(100);
│ │ │ │  assert!(heap.capacity() >= 100);
│ │ │ │  heap.push(4);
    Run
    │ │ │ │ -
    source

    pub fn reserve(&mut self, additional: usize)

    Reserves capacity for at least additional elements more than the │ │ │ │ +

    source

    pub fn reserve(&mut self, additional: usize)

    Reserves capacity for at least additional elements more than the │ │ │ │ current length. The allocator may reserve more space to speculatively │ │ │ │ avoid frequent allocations. After calling reserve, │ │ │ │ capacity will be greater than or equal to self.len() + additional. │ │ │ │ Does nothing if capacity is already sufficient.

    │ │ │ │
    §Panics
    │ │ │ │ -

    Panics if the new capacity overflows usize.

    │ │ │ │ +

    Panics if the new capacity overflows usize.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  let mut heap = BinaryHeap::new();
│ │ │ │  heap.reserve(100);
│ │ │ │  assert!(heap.capacity() >= 100);
│ │ │ │  heap.push(4);
    Run
    │ │ │ │
    1.63.0 · source

    pub fn try_reserve_exact( │ │ │ │ &mut self, │ │ │ │ - additional: usize │ │ │ │ -) -> Result<(), TryReserveError>

    Tries to reserve the minimum capacity for at least additional elements │ │ │ │ + additional: usize │ │ │ │ +) -> Result<(), TryReserveError>

    Tries to reserve the minimum capacity for at least additional elements │ │ │ │ more than the current length. Unlike try_reserve, this will not │ │ │ │ deliberately over-allocate to speculatively avoid frequent allocations. │ │ │ │ After calling try_reserve_exact, capacity will be greater than or │ │ │ │ equal to self.len() + additional if it returns Ok(()). │ │ │ │ Does nothing if the capacity is already sufficient.

    │ │ │ │

    Note that the allocator may give the collection more space than it │ │ │ │ requests. Therefore, capacity can not be relied upon to be precisely │ │ │ │ @@ -349,15 +349,15 @@ │ │ │ │ heap.try_reserve_exact(data.len())?; │ │ │ │ │ │ │ │ // Now we know this can't OOM in the middle of our complex work │ │ │ │ heap.extend(data.iter()); │ │ │ │ │ │ │ │ Ok(heap.pop()) │ │ │ │ }Run

    │ │ │ │ -
    1.63.0 · source

    pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

    Tries to reserve capacity for at least additional elements more than the │ │ │ │ +

    1.63.0 · source

    pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

    Tries to reserve capacity for at least additional elements more than the │ │ │ │ current length. The allocator may reserve more space to speculatively │ │ │ │ avoid frequent allocations. After calling try_reserve, capacity will be │ │ │ │ greater than or equal to self.len() + additional if it returns │ │ │ │ Ok(()). Does nothing if capacity is already sufficient. This method │ │ │ │ preserves the contents even if an error occurs.

    │ │ │ │
    §Errors
    │ │ │ │

    If the capacity overflows, or the allocator reports a failure, then an error │ │ │ │ @@ -383,26 +383,26 @@ │ │ │ │ │ │ │ │ 

    use std::collections::BinaryHeap;
│ │ │ │  let mut heap: BinaryHeap<i32> = BinaryHeap::with_capacity(100);
│ │ │ │  
│ │ │ │  assert!(heap.capacity() >= 100);
│ │ │ │  heap.shrink_to_fit();
│ │ │ │  assert!(heap.capacity() == 0);
    Run
    │ │ │ │ -
    1.56.0 · source

    pub fn shrink_to(&mut self, min_capacity: usize)

    Discards capacity with a lower bound.

    │ │ │ │ +
    1.56.0 · source

    pub fn shrink_to(&mut self, min_capacity: usize)

    Discards capacity with a lower bound.

    │ │ │ │

    The capacity will remain at least as large as both the length │ │ │ │ and the supplied value.

    │ │ │ │

    If the current capacity is less than the lower limit, this is a no-op.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  let mut heap: BinaryHeap<i32> = BinaryHeap::with_capacity(100);
│ │ │ │  
│ │ │ │  assert!(heap.capacity() >= 100);
│ │ │ │  heap.shrink_to(10);
│ │ │ │  assert!(heap.capacity() >= 10);
    Run
    │ │ │ │ -
    source

    pub fn as_slice(&self) -> &[T]

    🔬This is a nightly-only experimental API. (binary_heap_as_slice #83659)

    Returns a slice of all values in the underlying vector, in arbitrary │ │ │ │ +

    source

    pub fn as_slice(&self) -> &[T]

    🔬This is a nightly-only experimental API. (binary_heap_as_slice #83659)

    Returns a slice of all values in the underlying vector, in arbitrary │ │ │ │ order.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    #![feature(binary_heap_as_slice)]
│ │ │ │  use std::collections::BinaryHeap;
│ │ │ │  use std::io::{self, Write};
│ │ │ │ @@ -419,24 +419,24 @@
│ │ │ │  let heap = BinaryHeap::from([1, 2, 3, 4, 5, 6, 7]);
│ │ │ │  let vec = heap.into_vec();
│ │ │ │  
│ │ │ │  // Will print in some order
│ │ │ │  for x in vec {
│ │ │ │      println!("{x}");
│ │ │ │  }
    Run
    │ │ │ │ -
    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ -
    source

    pub fn len(&self) -> usize

    Returns the length of the binary heap.

    │ │ │ │ +
    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ +
    source

    pub fn len(&self) -> usize

    Returns the length of the binary heap.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  let heap = BinaryHeap::from([1, 3]);
│ │ │ │  
│ │ │ │  assert_eq!(heap.len(), 2);
    Run
    │ │ │ │ -
    source

    pub fn is_empty(&self) -> bool

    Checks if the binary heap is empty.

    │ │ │ │ +
    source

    pub fn is_empty(&self) -> bool

    Checks if the binary heap is empty.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  let mut heap = BinaryHeap::new();
│ │ │ │  
│ │ │ │  assert!(heap.is_empty());
│ │ │ │ @@ -472,58 +472,58 @@
│ │ │ │  let mut heap = BinaryHeap::from([1, 3]);
│ │ │ │  
│ │ │ │  assert!(!heap.is_empty());
│ │ │ │  
│ │ │ │  heap.clear();
│ │ │ │  
│ │ │ │  assert!(heap.is_empty());
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: Clone, A: Allocator + Clone> Clone for BinaryHeap<T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.4.0 · source§

    impl<T: Debug, A: Allocator> Debug for BinaryHeap<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Ord> Default for BinaryHeap<T>

    source§

    fn default() -> BinaryHeap<T>

    Creates an empty BinaryHeap<T>.

    │ │ │ │ -
    1.2.0 · source§

    impl<'a, T: 'a + Ord + Copy, A: Allocator> Extend<&'a T> for BinaryHeap<T, A>

    source§

    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, item: &'a T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl<T: Ord, A: Allocator> Extend<T> for BinaryHeap<T, A>

    source§

    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, item: T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.56.0 · source§

    impl<T: Ord, const N: usize> From<[T; N]> for BinaryHeap<T>

    source§

    fn from(arr: [T; N]) -> Self

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: Clone, A: Allocator + Clone> Clone for BinaryHeap<T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.4.0 · source§

    impl<T: Debug, A: Allocator> Debug for BinaryHeap<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Ord> Default for BinaryHeap<T>

    source§

    fn default() -> BinaryHeap<T>

    Creates an empty BinaryHeap<T>.

    │ │ │ │ +
    1.2.0 · source§

    impl<'a, T: 'a + Ord + Copy, A: Allocator> Extend<&'a T> for BinaryHeap<T, A>

    source§

    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, item: &'a T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl<T: Ord, A: Allocator> Extend<T> for BinaryHeap<T, A>

    source§

    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, item: T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.56.0 · source§

    impl<T: Ord, const N: usize> From<[T; N]> for BinaryHeap<T>

    source§

    fn from(arr: [T; N]) -> Self

    │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  
│ │ │ │  let mut h1 = BinaryHeap::from([1, 4, 2, 3]);
│ │ │ │  let mut h2: BinaryHeap<_> = [1, 4, 2, 3].into();
│ │ │ │  while let Some((a, b)) = h1.pop().zip(h2.pop()) {
│ │ │ │      assert_eq!(a, b);
│ │ │ │  }
    Run
    │ │ │ │ -
    1.5.0 · source§

    impl<T, A: Allocator> From<BinaryHeap<T, A>> for Vec<T, A>

    source§

    fn from(heap: BinaryHeap<T, A>) -> Vec<T, A>

    Converts a BinaryHeap<T> into a Vec<T>.

    │ │ │ │ +
    1.5.0 · source§

    impl<T, A: Allocator> From<BinaryHeap<T, A>> for Vec<T, A>

    source§

    fn from(heap: BinaryHeap<T, A>) -> Vec<T, A>

    Converts a BinaryHeap<T> into a Vec<T>.

    │ │ │ │

    This conversion requires no data movement or allocation, and has │ │ │ │ constant time complexity.

    │ │ │ │ -
    1.5.0 · source§

    impl<T: Ord, A: Allocator> From<Vec<T, A>> for BinaryHeap<T, A>

    source§

    fn from(vec: Vec<T, A>) -> BinaryHeap<T, A>

    Converts a Vec<T> into a BinaryHeap<T>.

    │ │ │ │ +
    1.5.0 · source§

    impl<T: Ord, A: Allocator> From<Vec<T, A>> for BinaryHeap<T, A>

    source§

    fn from(vec: Vec<T, A>) -> BinaryHeap<T, A>

    Converts a Vec<T> into a BinaryHeap<T>.

    │ │ │ │

    This conversion happens in-place, and has O(n) time complexity.

    │ │ │ │ -
    source§

    impl<T: Ord> FromIterator<T> for BinaryHeap<T>

    source§

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> BinaryHeap<T>

    Creates a value from an iterator. Read more
    source§

    impl<'a, T, A: Allocator> IntoIterator for &'a BinaryHeap<T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    §

    type IntoIter = Iter<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Iter<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<T, A: Allocator> IntoIterator for BinaryHeap<T, A>

    source§

    fn into_iter(self) -> IntoIter<T, A> ⓘ

    Creates a consuming iterator, that is, one that moves each value out of │ │ │ │ +

    source§

    impl<T: Ord> FromIterator<T> for BinaryHeap<T>

    source§

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> BinaryHeap<T>

    Creates a value from an iterator. Read more
    source§

    impl<'a, T, A: Allocator> IntoIterator for &'a BinaryHeap<T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    §

    type IntoIter = Iter<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Iter<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<T, A: Allocator> IntoIterator for BinaryHeap<T, A>

    source§

    fn into_iter(self) -> IntoIter<T, A> ⓘ

    Creates a consuming iterator, that is, one that moves each value out of │ │ │ │ the binary heap in arbitrary order. The binary heap cannot be used │ │ │ │ after calling this.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BinaryHeap;
│ │ │ │  let heap = BinaryHeap::from([1, 2, 3, 4]);
│ │ │ │  
│ │ │ │  // Print 1, 2, 3, 4 in arbitrary order
│ │ │ │  for x in heap.into_iter() {
│ │ │ │      // x has type i32, not &i32
│ │ │ │      println!("{x}");
│ │ │ │  }
    Run
    │ │ │ │ -
    §

    type Item = T

    The type of the elements being iterated over.
    §

    type IntoIter = IntoIter<T, A>

    Which kind of iterator are we turning this into?

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for BinaryHeap<T, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<T, A> RefUnwindSafe for BinaryHeap<T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<T, A> Send for BinaryHeap<T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<T, A> Sync for BinaryHeap<T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<T, A> Unpin for BinaryHeap<T, A>
    where │ │ │ │ - A: Unpin, │ │ │ │ - T: Unpin,

    §

    impl<T, A> UnwindSafe for BinaryHeap<T, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +
    §

    type Item = T

    The type of the elements being iterated over.
    §

    type IntoIter = IntoIter<T, A>

    Which kind of iterator are we turning this into?

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for BinaryHeap<T, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<T, A> RefUnwindSafe for BinaryHeap<T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<T, A> Send for BinaryHeap<T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<T, A> Sync for BinaryHeap<T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<T, A> Unpin for BinaryHeap<T, A>
    where │ │ │ │ + A: Unpin, │ │ │ │ + T: Unpin,

    §

    impl<T, A> UnwindSafe for BinaryHeap<T, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.Drain.html │ │ │ │ @@ -1,220 +1,220 @@ │ │ │ │ Drain in alloc::collections::binary_heap - Rust
    │ │ │ │

    Struct alloc::collections::binary_heap::Drain

    1.6.0 · source · 
    pub struct Drain<'a, T: 'a, A: Allocator = Global> { /* private fields */ }
    Expand description

    A draining iterator over the elements of a BinaryHeap.

    │ │ │ │

    This struct is created by BinaryHeap::drain(). See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Implementations§

    source§

    impl<T, A: Allocator> Drain<'_, T, A>

    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<'a, T: Debug + 'a, A: Debug + Allocator> Debug for Drain<'a, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>

    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    impl<T, A: Allocator> Iterator for Drain<'_, T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Implementations§

    source§

    impl<T, A: Allocator> Drain<'_, T, A>

    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<'a, T: Debug + 'a, A: Debug + Allocator> Debug for Drain<'a, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>

    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    impl<T, A: Allocator> Iterator for Drain<'_, T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for Drain<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, A> Send for Drain<'a, T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<'a, T, A> Sync for Drain<'a, T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, A> Unpin for Drain<'a, T, A>

    §

    impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for Drain<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, A> Send for Drain<'a, T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<'a, T, A> Sync for Drain<'a, T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, A> Unpin for Drain<'a, T, A>

    §

    impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.DrainSorted.html │ │ │ │ @@ -1,201 +1,201 @@ │ │ │ │ DrainSorted in alloc::collections::binary_heap - Rust
    │ │ │ │ -

    Struct alloc::collections::binary_heap::DrainSorted

    source · 
    pub struct DrainSorted<'a, T: Ord, A: Allocator = Global> { /* private fields */ }
    🔬This is a nightly-only experimental API. (binary_heap_drain_sorted #59278)
    Expand description

    A draining iterator over the elements of a BinaryHeap.

    │ │ │ │ +

    Struct alloc::collections::binary_heap::DrainSorted

    source · 
    pub struct DrainSorted<'a, T: Ord, A: Allocator = Global> { /* private fields */ }
    🔬This is a nightly-only experimental API. (binary_heap_drain_sorted #59278)
    Expand description

    A draining iterator over the elements of a BinaryHeap.

    │ │ │ │

    This struct is created by BinaryHeap::drain_sorted(). See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Implementations§

    source§

    impl<'a, T: Ord, A: Allocator> DrainSorted<'a, T, A>

    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<'a, T: Debug + Ord, A: Debug + Allocator> Debug for DrainSorted<'a, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T: Ord, A: Allocator> Drop for DrainSorted<'a, T, A>

    source§

    fn drop(&mut self)

    Removes heap elements in heap order.

    │ │ │ │ -
    source§

    impl<T: Ord, A: Allocator> ExactSizeIterator for DrainSorted<'_, T, A>

    1.0.0 · source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<T: Ord, A: Allocator> Iterator for DrainSorted<'_, T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Implementations§

    source§

    impl<'a, T: Ord, A: Allocator> DrainSorted<'a, T, A>

    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<'a, T: Debug + Ord, A: Debug + Allocator> Debug for DrainSorted<'a, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T: Ord, A: Allocator> Drop for DrainSorted<'a, T, A>

    source§

    fn drop(&mut self)

    Removes heap elements in heap order.

    │ │ │ │ +
    source§

    impl<T: Ord, A: Allocator> ExactSizeIterator for DrainSorted<'_, T, A>

    1.0.0 · source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<T: Ord, A: Allocator> Iterator for DrainSorted<'_, T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T: Ord, A: Allocator> FusedIterator for DrainSorted<'_, T, A>

    source§

    impl<T: Ord, A: Allocator> TrustedLen for DrainSorted<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for DrainSorted<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for DrainSorted<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, A> Send for DrainSorted<'a, T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<'a, T, A> Sync for DrainSorted<'a, T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, A> Unpin for DrainSorted<'a, T, A>

    §

    impl<'a, T, A = Global> !UnwindSafe for DrainSorted<'a, T, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T: Ord, A: Allocator> FusedIterator for DrainSorted<'_, T, A>

    source§

    impl<T: Ord, A: Allocator> TrustedLen for DrainSorted<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for DrainSorted<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for DrainSorted<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, A> Send for DrainSorted<'a, T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<'a, T, A> Sync for DrainSorted<'a, T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, A> Unpin for DrainSorted<'a, T, A>

    §

    impl<'a, T, A = Global> !UnwindSafe for DrainSorted<'a, T, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.IntoIter.html │ │ │ │ @@ -1,228 +1,228 @@ │ │ │ │ IntoIter in alloc::collections::binary_heap - Rust
    │ │ │ │

    Struct alloc::collections::binary_heap::IntoIter

    1.0.0 · source · 
    pub struct IntoIter<T, A: Allocator = Global> { /* private fields */ }
    Expand description

    An owning iterator over the elements of a BinaryHeap.

    │ │ │ │

    This struct is created by BinaryHeap::into_iter() │ │ │ │ -(provided by the IntoIterator trait). See its documentation for more.

    │ │ │ │ -

    Implementations§

    source§

    impl<T, A: Allocator> IntoIter<T, A>

    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>

    source§

    fn clone(&self) -> IntoIter<T, A> ⓘ

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for IntoIter<T>

    source§

    fn default() -> Self

    Creates an empty binary_heap::IntoIter.

    │ │ │ │ +(provided by the IntoIterator trait). See its documentation for more.

    │ │ │ │ +

    Implementations§

    source§

    impl<T, A: Allocator> IntoIter<T, A>

    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>

    source§

    fn clone(&self) -> IntoIter<T, A> ⓘ

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for IntoIter<T>

    source§

    fn default() -> Self

    Creates an empty binary_heap::IntoIter.

    │ │ │ │ │ │ │ │ 
    let iter: binary_heap::IntoIter<u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>

    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    impl<T, A: Allocator> Iterator for IntoIter<T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>

    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    impl<T, A: Allocator> Iterator for IntoIter<T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T, A: Allocator> FusedIterator for IntoIter<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for IntoIter<T, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<T, A> RefUnwindSafe for IntoIter<T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<T, A> Send for IntoIter<T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<T, A> Sync for IntoIter<T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<T, A> Unpin for IntoIter<T, A>
    where │ │ │ │ - A: Unpin, │ │ │ │ - T: Unpin,

    §

    impl<T, A> UnwindSafe for IntoIter<T, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - T: UnwindSafe + RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T, A: Allocator> FusedIterator for IntoIter<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for IntoIter<T, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<T, A> RefUnwindSafe for IntoIter<T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<T, A> Send for IntoIter<T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<T, A> Sync for IntoIter<T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<T, A> Unpin for IntoIter<T, A>
    where │ │ │ │ + A: Unpin, │ │ │ │ + T: Unpin,

    §

    impl<T, A> UnwindSafe for IntoIter<T, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + T: UnwindSafe + RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.IntoIterSorted.html │ │ │ │ @@ -1,203 +1,203 @@ │ │ │ │ IntoIterSorted in alloc::collections::binary_heap - Rust
    │ │ │ │ -

    Struct alloc::collections::binary_heap::IntoIterSorted

    source · 
    pub struct IntoIterSorted<T, A: Allocator = Global> { /* private fields */ }
    🔬This is a nightly-only experimental API. (binary_heap_into_iter_sorted #59278)

    Implementations§

    source§

    impl<T, A: Allocator> IntoIterSorted<T, A>

    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: Clone, A: Clone + Allocator> Clone for IntoIterSorted<T, A>

    source§

    fn clone(&self) -> IntoIterSorted<T, A> ⓘ

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Debug, A: Debug + Allocator> Debug for IntoIterSorted<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Ord, A: Allocator> ExactSizeIterator for IntoIterSorted<T, A>

    1.0.0 · source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<T: Ord, A: Allocator> Iterator for IntoIterSorted<T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Struct alloc::collections::binary_heap::IntoIterSorted

    source · 
    pub struct IntoIterSorted<T, A: Allocator = Global> { /* private fields */ }
    🔬This is a nightly-only experimental API. (binary_heap_into_iter_sorted #59278)

    Implementations§

    source§

    impl<T, A: Allocator> IntoIterSorted<T, A>

    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: Clone, A: Clone + Allocator> Clone for IntoIterSorted<T, A>

    source§

    fn clone(&self) -> IntoIterSorted<T, A> ⓘ

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Debug, A: Debug + Allocator> Debug for IntoIterSorted<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Ord, A: Allocator> ExactSizeIterator for IntoIterSorted<T, A>

    1.0.0 · source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<T: Ord, A: Allocator> Iterator for IntoIterSorted<T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T: Ord, A: Allocator> FusedIterator for IntoIterSorted<T, A>

    source§

    impl<T: Ord, A: Allocator> TrustedLen for IntoIterSorted<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for IntoIterSorted<T, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<T, A> RefUnwindSafe for IntoIterSorted<T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<T, A> Send for IntoIterSorted<T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<T, A> Sync for IntoIterSorted<T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<T, A> Unpin for IntoIterSorted<T, A>
    where │ │ │ │ - A: Unpin, │ │ │ │ - T: Unpin,

    §

    impl<T, A> UnwindSafe for IntoIterSorted<T, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T: Ord, A: Allocator> FusedIterator for IntoIterSorted<T, A>

    source§

    impl<T: Ord, A: Allocator> TrustedLen for IntoIterSorted<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for IntoIterSorted<T, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<T, A> RefUnwindSafe for IntoIterSorted<T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<T, A> Send for IntoIterSorted<T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<T, A> Sync for IntoIterSorted<T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<T, A> Unpin for IntoIterSorted<T, A>
    where │ │ │ │ + A: Unpin, │ │ │ │ + T: Unpin,

    §

    impl<T, A> UnwindSafe for IntoIterSorted<T, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.Iter.html │ │ │ │ @@ -1,216 +1,216 @@ │ │ │ │ Iter in alloc::collections::binary_heap - Rust
    │ │ │ │

    Struct alloc::collections::binary_heap::Iter

    1.0.0 · source · 
    pub struct Iter<'a, T: 'a> { /* private fields */ }
    Expand description

    An iterator over the elements of a BinaryHeap.

    │ │ │ │

    This struct is created by BinaryHeap::iter(). See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T> Clone for Iter<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for Iter<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T> DoubleEndedIterator for Iter<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for Iter<'_, T>

    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    impl<'a, T> Iterator for Iter<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    source§

    impl<T> Clone for Iter<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for Iter<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T> DoubleEndedIterator for Iter<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for Iter<'_, T>

    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    impl<'a, T> Iterator for Iter<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Iter<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Iter<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Iter<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for Iter<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Sync for Iter<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for Iter<'a, T>

    §

    impl<'a, T> UnwindSafe for Iter<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Iter<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Iter<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Iter<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for Iter<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Sync for Iter<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for Iter<'a, T>

    §

    impl<'a, T> UnwindSafe for Iter<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/binary_heap/struct.PeekMut.html │ │ │ │ @@ -1,23 +1,23 @@ │ │ │ │ PeekMut in alloc::collections::binary_heap - Rust
    │ │ │ │ -

    Struct alloc::collections::binary_heap::PeekMut

    1.12.0 · source · 
    pub struct PeekMut<'a, T: 'a + Ord, A: Allocator = Global> { /* private fields */ }
    Expand description

    Structure wrapping a mutable reference to the greatest item on a │ │ │ │ +

    Struct alloc::collections::binary_heap::PeekMut

    1.12.0 · source · 
    pub struct PeekMut<'a, T: 'a + Ord, A: Allocator = Global> { /* private fields */ }
    Expand description

    Structure wrapping a mutable reference to the greatest item on a │ │ │ │ BinaryHeap.

    │ │ │ │

    This struct is created by the peek_mut method on BinaryHeap. See │ │ │ │ its documentation for more.

    │ │ │ │ -

    Implementations§

    source§

    impl<'a, T: Ord, A: Allocator> PeekMut<'a, T, A>

    1.18.0 · source

    pub fn pop(this: PeekMut<'a, T, A>) -> T

    Removes the peeked value from the heap and returns it.

    │ │ │ │ -

    Trait Implementations§

    1.17.0 · source§

    impl<T: Ord + Debug, A: Allocator> Debug for PeekMut<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Ord, A: Allocator> Deref for PeekMut<'_, T, A>

    §

    type Target = T

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &T

    Dereferences the value.
    source§

    impl<T: Ord, A: Allocator> DerefMut for PeekMut<'_, T, A>

    source§

    fn deref_mut(&mut self) -> &mut T

    Mutably dereferences the value.
    source§

    impl<T: Ord, A: Allocator> Drop for PeekMut<'_, T, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for PeekMut<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for PeekMut<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, A> Send for PeekMut<'a, T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<'a, T, A> Sync for PeekMut<'a, T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, A> Unpin for PeekMut<'a, T, A>

    §

    impl<'a, T, A = Global> !UnwindSafe for PeekMut<'a, T, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Implementations§

    source§

    impl<'a, T: Ord, A: Allocator> PeekMut<'a, T, A>

    1.18.0 · source

    pub fn pop(this: PeekMut<'a, T, A>) -> T

    Removes the peeked value from the heap and returns it.

    │ │ │ │ +

    Trait Implementations§

    1.17.0 · source§

    impl<T: Ord + Debug, A: Allocator> Debug for PeekMut<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Ord, A: Allocator> Deref for PeekMut<'_, T, A>

    §

    type Target = T

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &T

    Dereferences the value.
    source§

    impl<T: Ord, A: Allocator> DerefMut for PeekMut<'_, T, A>

    source§

    fn deref_mut(&mut self) -> &mut T

    Mutably dereferences the value.
    source§

    impl<T: Ord, A: Allocator> Drop for PeekMut<'_, T, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for PeekMut<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for PeekMut<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, A> Send for PeekMut<'a, T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<'a, T, A> Sync for PeekMut<'a, T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, A> Unpin for PeekMut<'a, T, A>

    §

    impl<'a, T, A = Global> !UnwindSafe for PeekMut<'a, T, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/enum.Entry.html │ │ │ │ @@ -1,56 +1,56 @@ │ │ │ │ Entry in alloc::collections::btree_map - Rust
    │ │ │ │ -

    Enum alloc::collections::btree_map::Entry

    1.0.0 · source · 
    pub enum Entry<'a, K: 'a, V: 'a, A: Allocator + Clone = Global> {
│ │ │ │ +    
    Enum alloc::collections::btree_map::Entry
    1.0.0 · source · 
    pub enum Entry<'a, K: 'a, V: 'a, A: Allocator + Clone = Global> {
│ │ │ │      Vacant(VacantEntry<'a, K, V, A>),
│ │ │ │      Occupied(OccupiedEntry<'a, K, V, A>),
│ │ │ │  }
    Expand description
    A view into a single entry in a map, which may either be vacant or occupied.
    
│ │ │ │  
    This enum is constructed from the entry method on BTreeMap.
    
│ │ │ │  
    Variants§
    §
    Vacant(VacantEntry<'a, K, V, A>)
    A vacant entry.
    
│ │ │ │  
    §
    Occupied(OccupiedEntry<'a, K, V, A>)
    An occupied entry.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, K: Ord, V, A: Allocator + Clone> Entry<'a, K, V, A>
    source
    pub fn or_insert(self, default: V) -> &'a mut V
    Ensures a value is in the entry by inserting the default if empty, and returns
│ │ │ │ +
    Implementations§
    source§
    impl<'a, K: Ord, V, A: Allocator + Clone> Entry<'a, K, V, A>
    source
    pub fn or_insert(self, default: V) -> &'a mut V
    Ensures a value is in the entry by inserting the default if empty, and returns
│ │ │ │  a mutable reference to the value in the entry.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, usize> = BTreeMap::new();
│ │ │ │  map.entry("poneyland").or_insert(12);
│ │ │ │  
│ │ │ │  assert_eq!(map["poneyland"], 12);
    Run
    
│ │ │ │ -
    source
    pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V
    Ensures a value is in the entry by inserting the result of the default function if empty,
│ │ │ │ +
    source
    pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V
    Ensures a value is in the entry by inserting the result of the default function if empty,
│ │ │ │  and returns a mutable reference to the value in the entry.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, String> = BTreeMap::new();
│ │ │ │  let s = "hoho".to_string();
│ │ │ │  
│ │ │ │  map.entry("poneyland").or_insert_with(|| s);
│ │ │ │  
│ │ │ │  assert_eq!(map["poneyland"], "hoho".to_string());
    Run
    
│ │ │ │ -
    1.50.0 · source
    pub fn or_insert_with_key<F: FnOnce(&K) -> V>(self, default: F) -> &'a mut V
    Ensures a value is in the entry by inserting, if empty, the result of the default function.
│ │ │ │ +
    1.50.0 · source
    pub fn or_insert_with_key<F: FnOnce(&K) -> V>(self, default: F) -> &'a mut V
    Ensures a value is in the entry by inserting, if empty, the result of the default function.
│ │ │ │  This method allows for generating key-derived values for insertion by providing the default
│ │ │ │  function a reference to the key that was moved during the .entry(key) method call.
    
│ │ │ │  
    The reference to the moved key is provided so that cloning or copying the key is
│ │ │ │  unnecessary, unlike with .or_insert_with(|| ... ).
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, usize> = BTreeMap::new();
│ │ │ │  
│ │ │ │  map.entry("poneyland").or_insert_with_key(|key| key.chars().count());
│ │ │ │  
│ │ │ │  assert_eq!(map["poneyland"], 9);
    Run
    
│ │ │ │ -
    1.10.0 · source
    pub fn key(&self) -> &K
    Returns a reference to this entry’s key.
    
│ │ │ │ +
    1.10.0 · source
    pub fn key(&self) -> &K
    Returns a reference to this entry’s key.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, usize> = BTreeMap::new();
│ │ │ │  assert_eq!(map.entry("poneyland").key(), &"poneyland");
    Run
    
│ │ │ │  
    1.26.0 · source
    pub fn and_modify<F>(self, f: F) -> Self
    where
│ │ │ │ -    F: FnOnce(&mut V),
    Provides in-place mutable access to an occupied entry before any
│ │ │ │ +    F: FnOnce(&mut V),
    Provides in-place mutable access to an occupied entry before any
│ │ │ │  potential inserts into the map.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, usize> = BTreeMap::new();
│ │ │ │  
│ │ │ │  map.entry("poneyland")
│ │ │ │ @@ -58,40 +58,40 @@
│ │ │ │     .or_insert(42);
│ │ │ │  assert_eq!(map["poneyland"], 42);
│ │ │ │  
│ │ │ │  map.entry("poneyland")
│ │ │ │     .and_modify(|e| { *e += 1 })
│ │ │ │     .or_insert(42);
│ │ │ │  assert_eq!(map["poneyland"], 43);
    Run
    
│ │ │ │ -
    source§
    impl<'a, K: Ord, V: Default, A: Allocator + Clone> Entry<'a, K, V, A>
    1.28.0 · source
    pub fn or_default(self) -> &'a mut V
    Ensures a value is in the entry by inserting the default value if empty,
│ │ │ │ +
    source§
    impl<'a, K: Ord, V: Default, A: Allocator + Clone> Entry<'a, K, V, A>
    1.28.0 · source
    pub fn or_default(self) -> &'a mut V
    Ensures a value is in the entry by inserting the default value if empty,
│ │ │ │  and returns a mutable reference to the value in the entry.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, Option<usize>> = BTreeMap::new();
│ │ │ │  map.entry("poneyland").or_default();
│ │ │ │  
│ │ │ │  assert_eq!(map["poneyland"], None);
    Run
    
│ │ │ │ -

    Trait Implementations§

    1.12.0 · source§

    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for Entry<'_, K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V, A> Freeze for Entry<'a, K, V, A>
    where │ │ │ │ - A: Freeze, │ │ │ │ - K: Freeze,

    §

    impl<'a, K, V, A> RefUnwindSafe for Entry<'a, K, V, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V, A> Send for Entry<'a, K, V, A>
    where │ │ │ │ - A: Send, │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<'a, K, V, A> Sync for Entry<'a, K, V, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V, A> Unpin for Entry<'a, K, V, A>
    where │ │ │ │ - A: Unpin, │ │ │ │ - K: Unpin,

    §

    impl<'a, K, V, A = Global> !UnwindSafe for Entry<'a, K, V, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    1.12.0 · source§

    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for Entry<'_, K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V, A> Freeze for Entry<'a, K, V, A>
    where │ │ │ │ + A: Freeze, │ │ │ │ + K: Freeze,

    §

    impl<'a, K, V, A> RefUnwindSafe for Entry<'a, K, V, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V, A> Send for Entry<'a, K, V, A>
    where │ │ │ │ + A: Send, │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<'a, K, V, A> Sync for Entry<'a, K, V, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V, A> Unpin for Entry<'a, K, V, A>
    where │ │ │ │ + A: Unpin, │ │ │ │ + K: Unpin,

    §

    impl<'a, K, V, A = Global> !UnwindSafe for Entry<'a, K, V, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.BTreeMap.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ BTreeMap in alloc::collections::btree_map - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_map::BTreeMap

    1.0.0 · source · 
    pub struct BTreeMap<K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An ordered map based on a B-Tree.

    │ │ │ │ +

    Struct alloc::collections::btree_map::BTreeMap

    1.0.0 · source · 
    pub struct BTreeMap<K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An ordered map based on a B-Tree.

    │ │ │ │

    B-Trees represent a fundamental compromise between cache-efficiency and actually minimizing │ │ │ │ the amount of work performed in a search. In theory, a binary search tree (BST) is the optimal │ │ │ │ choice for a sorted map, as a perfectly balanced BST performs the theoretical minimum amount of │ │ │ │ comparisons necessary to find an element (log2n). However, in practice the way this │ │ │ │ is done is very inefficient for modern computer architectures. In particular, every element │ │ │ │ is stored in its own individually heap-allocated node. This means that every single insertion │ │ │ │ triggers a heap-allocation, and every single comparison should be a cache-miss. Since these │ │ │ │ @@ -19,16 +19,16 @@ │ │ │ │

    Currently, our implementation simply performs naive linear search. This provides excellent │ │ │ │ performance on small nodes of elements which are cheap to compare. However in the future we │ │ │ │ would like to further explore choosing the optimal search strategy based on the choice of B, │ │ │ │ and possibly other factors. Using linear search, searching for a random element is expected │ │ │ │ to take B * log(n) comparisons, which is generally worse than a BST. In practice, │ │ │ │ however, performance is excellent.

    │ │ │ │

    It is a logic error for a key to be modified in such a way that the key’s ordering relative to │ │ │ │ -any other key, as determined by the Ord trait, changes while it is in the map. This is │ │ │ │ -normally only possible through Cell, RefCell, global state, I/O, or unsafe code. │ │ │ │ +any other key, as determined by the Ord trait, changes while it is in the map. This is │ │ │ │ +normally only possible through Cell, RefCell, global state, I/O, or unsafe code. │ │ │ │ The behavior resulting from such a logic error is not specified, but will be encapsulated to the │ │ │ │ BTreeMap that observed the logic error and not result in undefined behavior. This could │ │ │ │ include panics, incorrect results, aborts, memory leaks, and non-termination.

    │ │ │ │

    Iterators obtained from functions such as BTreeMap::iter, BTreeMap::values, or │ │ │ │ BTreeMap::keys produce their items in order by key, and take worst-case logarithmic and │ │ │ │ amortized constant time per item returned.

    │ │ │ │

    §Examples

    │ │ │ │ @@ -112,15 +112,15 @@ │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  
│ │ │ │  // entries can now be inserted into the empty map
│ │ │ │  map.insert(1, "a");
    Run
    │ │ │ │ -
    source§

    impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A>

    source

    pub fn clear(&mut self)

    Clears the map, removing all elements.

    │ │ │ │ +
    source§

    impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A>

    source

    pub fn clear(&mut self)

    Clears the map, removing all elements.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut a = BTreeMap::new();
│ │ │ │  a.insert(1, "a");
│ │ │ │  a.clear();
│ │ │ │  assert!(a.is_empty());
    Run
    │ │ │ │ @@ -129,149 +129,149 @@ │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  use std::alloc::Global;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new_in(Global);
│ │ │ │  
│ │ │ │  // entries can now be inserted into the empty map
│ │ │ │  map.insert(1, "a");
    Run
    │ │ │ │ -
    source§

    impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A>

    source

    pub fn get<Q>(&self, key: &Q) -> Option<&V>
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    Returns a reference to the value corresponding to the key.

    │ │ │ │ +
    source§

    impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A>

    source

    pub fn get<Q>(&self, key: &Q) -> Option<&V>
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    Returns a reference to the value corresponding to the key.

    │ │ │ │

    The key may be any borrowed form of the map’s key type, but the ordering │ │ │ │ on the borrowed form must match the ordering on the key type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(1, "a");
│ │ │ │  assert_eq!(map.get(&1), Some(&"a"));
│ │ │ │  assert_eq!(map.get(&2), None);
    Run
    │ │ │ │ -
    1.40.0 · source

    pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    Returns the key-value pair corresponding to the supplied key.

    │ │ │ │ +
    1.40.0 · source

    pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    Returns the key-value pair corresponding to the supplied key.

    │ │ │ │

    The supplied key may be any borrowed form of the map’s key type, but the ordering │ │ │ │ on the borrowed form must match the ordering on the key type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(1, "a");
│ │ │ │  assert_eq!(map.get_key_value(&1), Some((&1, &"a")));
│ │ │ │  assert_eq!(map.get_key_value(&2), None);
    Run
    │ │ │ │ -
    1.66.0 · source

    pub fn first_key_value(&self) -> Option<(&K, &V)>
    where │ │ │ │ - K: Ord,

    Returns the first key-value pair in the map. │ │ │ │ +

    1.66.0 · source

    pub fn first_key_value(&self) -> Option<(&K, &V)>
    where │ │ │ │ + K: Ord,

    Returns the first key-value pair in the map. │ │ │ │ The key in this pair is the minimum key in the map.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  assert_eq!(map.first_key_value(), None);
│ │ │ │  map.insert(1, "b");
│ │ │ │  map.insert(2, "a");
│ │ │ │  assert_eq!(map.first_key_value(), Some((&1, &"b")));
    Run
    │ │ │ │ -
    1.66.0 · source

    pub fn first_entry(&mut self) -> Option<OccupiedEntry<'_, K, V, A>>
    where │ │ │ │ - K: Ord,

    Returns the first entry in the map for in-place manipulation. │ │ │ │ +

    1.66.0 · source

    pub fn first_entry(&mut self) -> Option<OccupiedEntry<'_, K, V, A>>
    where │ │ │ │ + K: Ord,

    Returns the first entry in the map for in-place manipulation. │ │ │ │ The key of this entry is the minimum key in the map.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(1, "a");
│ │ │ │  map.insert(2, "b");
│ │ │ │  if let Some(mut entry) = map.first_entry() {
│ │ │ │      if *entry.key() > 0 {
│ │ │ │          entry.insert("first");
│ │ │ │      }
│ │ │ │  }
│ │ │ │  assert_eq!(*map.get(&1).unwrap(), "first");
│ │ │ │  assert_eq!(*map.get(&2).unwrap(), "b");
    Run
    │ │ │ │ -
    1.66.0 · source

    pub fn pop_first(&mut self) -> Option<(K, V)>
    where │ │ │ │ - K: Ord,

    Removes and returns the first element in the map. │ │ │ │ +

    1.66.0 · source

    pub fn pop_first(&mut self) -> Option<(K, V)>
    where │ │ │ │ + K: Ord,

    Removes and returns the first element in the map. │ │ │ │ The key of this element is the minimum key that was in the map.

    │ │ │ │
    §Examples
    │ │ │ │

    Draining elements in ascending order, while keeping a usable map each iteration.

    │ │ │ │ │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(1, "a");
│ │ │ │  map.insert(2, "b");
│ │ │ │  while let Some((key, _val)) = map.pop_first() {
│ │ │ │      assert!(map.iter().all(|(k, _v)| *k > key));
│ │ │ │  }
│ │ │ │  assert!(map.is_empty());
    Run
    │ │ │ │ -
    1.66.0 · source

    pub fn last_key_value(&self) -> Option<(&K, &V)>
    where │ │ │ │ - K: Ord,

    Returns the last key-value pair in the map. │ │ │ │ +

    1.66.0 · source

    pub fn last_key_value(&self) -> Option<(&K, &V)>
    where │ │ │ │ + K: Ord,

    Returns the last key-value pair in the map. │ │ │ │ The key in this pair is the maximum key in the map.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(1, "b");
│ │ │ │  map.insert(2, "a");
│ │ │ │  assert_eq!(map.last_key_value(), Some((&2, &"a")));
    Run
    │ │ │ │ -
    1.66.0 · source

    pub fn last_entry(&mut self) -> Option<OccupiedEntry<'_, K, V, A>>
    where │ │ │ │ - K: Ord,

    Returns the last entry in the map for in-place manipulation. │ │ │ │ +

    1.66.0 · source

    pub fn last_entry(&mut self) -> Option<OccupiedEntry<'_, K, V, A>>
    where │ │ │ │ + K: Ord,

    Returns the last entry in the map for in-place manipulation. │ │ │ │ The key of this entry is the maximum key in the map.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(1, "a");
│ │ │ │  map.insert(2, "b");
│ │ │ │  if let Some(mut entry) = map.last_entry() {
│ │ │ │      if *entry.key() > 0 {
│ │ │ │          entry.insert("last");
│ │ │ │      }
│ │ │ │  }
│ │ │ │  assert_eq!(*map.get(&1).unwrap(), "a");
│ │ │ │  assert_eq!(*map.get(&2).unwrap(), "last");
    Run
    │ │ │ │ -
    1.66.0 · source

    pub fn pop_last(&mut self) -> Option<(K, V)>
    where │ │ │ │ - K: Ord,

    Removes and returns the last element in the map. │ │ │ │ +

    1.66.0 · source

    pub fn pop_last(&mut self) -> Option<(K, V)>
    where │ │ │ │ + K: Ord,

    Removes and returns the last element in the map. │ │ │ │ The key of this element is the maximum key that was in the map.

    │ │ │ │
    §Examples
    │ │ │ │

    Draining elements in descending order, while keeping a usable map each iteration.

    │ │ │ │ │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(1, "a");
│ │ │ │  map.insert(2, "b");
│ │ │ │  while let Some((key, _val)) = map.pop_last() {
│ │ │ │      assert!(map.iter().all(|(k, _v)| *k < key));
│ │ │ │  }
│ │ │ │  assert!(map.is_empty());
    Run
    │ │ │ │ -
    source

    pub fn contains_key<Q>(&self, key: &Q) -> bool
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    Returns true if the map contains a value for the specified key.

    │ │ │ │ +
    source

    pub fn contains_key<Q>(&self, key: &Q) -> bool
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    Returns true if the map contains a value for the specified key.

    │ │ │ │

    The key may be any borrowed form of the map’s key type, but the ordering │ │ │ │ on the borrowed form must match the ordering on the key type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(1, "a");
│ │ │ │  assert_eq!(map.contains_key(&1), true);
│ │ │ │  assert_eq!(map.contains_key(&2), false);
    Run
    │ │ │ │ -
    source

    pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    Returns a mutable reference to the value corresponding to the key.

    │ │ │ │ +
    source

    pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    Returns a mutable reference to the value corresponding to the key.

    │ │ │ │

    The key may be any borrowed form of the map’s key type, but the ordering │ │ │ │ on the borrowed form must match the ordering on the key type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(1, "a");
│ │ │ │  if let Some(x) = map.get_mut(&1) {
│ │ │ │      *x = "b";
│ │ │ │  }
│ │ │ │  assert_eq!(map[&1], "b");
    Run
    │ │ │ │ -
    source

    pub fn insert(&mut self, key: K, value: V) -> Option<V>
    where │ │ │ │ - K: Ord,

    Inserts a key-value pair into the map.

    │ │ │ │ +
    source

    pub fn insert(&mut self, key: K, value: V) -> Option<V>
    where │ │ │ │ + K: Ord,

    Inserts a key-value pair into the map.

    │ │ │ │

    If the map did not have this key present, None is returned.

    │ │ │ │

    If the map did have this key present, the value is updated, and the old │ │ │ │ value is returned. The key is not updated, though; this matters for │ │ │ │ types that can be == without being identical. See the module-level │ │ │ │ documentation for more.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │ @@ -283,16 +283,16 @@
│ │ │ │  map.insert(37, "b");
│ │ │ │  assert_eq!(map.insert(37, "c"), Some("b"));
│ │ │ │  assert_eq!(map[&37], "c");
    Run
    │ │ │ │
    source

    pub fn try_insert( │ │ │ │ &mut self, │ │ │ │ key: K, │ │ │ │ value: V │ │ │ │ -) -> Result<&mut V, OccupiedError<'_, K, V, A>>
    where │ │ │ │ - K: Ord,

    🔬This is a nightly-only experimental API. (map_try_insert #82766)

    Tries to insert a key-value pair into the map, and returns │ │ │ │ +) -> Result<&mut V, OccupiedError<'_, K, V, A>>

    where │ │ │ │ + K: Ord,
    🔬This is a nightly-only experimental API. (map_try_insert #82766)

    Tries to insert a key-value pair into the map, and returns │ │ │ │ a mutable reference to the value in the entry.

    │ │ │ │

    If the map already had this key present, nothing is updated, and │ │ │ │ an error containing the occupied entry and the value is returned.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(map_try_insert)]
│ │ │ │  
│ │ │ │  use std::collections::BTreeMap;
│ │ │ │ @@ -300,55 +300,55 @@
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  assert_eq!(map.try_insert(37, "a").unwrap(), &"a");
│ │ │ │  
│ │ │ │  let err = map.try_insert(37, "b").unwrap_err();
│ │ │ │  assert_eq!(err.entry.key(), &37);
│ │ │ │  assert_eq!(err.entry.get(), &"a");
│ │ │ │  assert_eq!(err.value, "b");
    Run
    │ │ │ │ -
    source

    pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    Removes a key from the map, returning the value at the key if the key │ │ │ │ +

    source

    pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    Removes a key from the map, returning the value at the key if the key │ │ │ │ was previously in the map.

    │ │ │ │

    The key may be any borrowed form of the map’s key type, but the ordering │ │ │ │ on the borrowed form must match the ordering on the key type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(1, "a");
│ │ │ │  assert_eq!(map.remove(&1), Some("a"));
│ │ │ │  assert_eq!(map.remove(&1), None);
    Run
    │ │ │ │ -
    1.45.0 · source

    pub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    Removes a key from the map, returning the stored key and value if the key │ │ │ │ +

    1.45.0 · source

    pub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    Removes a key from the map, returning the stored key and value if the key │ │ │ │ was previously in the map.

    │ │ │ │

    The key may be any borrowed form of the map’s key type, but the ordering │ │ │ │ on the borrowed form must match the ordering on the key type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(1, "a");
│ │ │ │  assert_eq!(map.remove_entry(&1), Some((1, "a")));
│ │ │ │  assert_eq!(map.remove_entry(&1), None);
    Run
    │ │ │ │
    1.53.0 · source

    pub fn retain<F>(&mut self, f: F)
    where │ │ │ │ - K: Ord, │ │ │ │ - F: FnMut(&K, &mut V) -> bool,

    Retains only the elements specified by the predicate.

    │ │ │ │ + K: Ord, │ │ │ │ + F: FnMut(&K, &mut V) -> bool,

    Retains only the elements specified by the predicate.

    │ │ │ │

    In other words, remove all pairs (k, v) for which f(&k, &mut v) returns false. │ │ │ │ The elements are visited in ascending key order.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<i32, i32> = (0..8).map(|x| (x, x*10)).collect();
│ │ │ │  // Keep only the elements with even-numbered keys.
│ │ │ │  map.retain(|&k, _| k % 2 == 0);
│ │ │ │  assert!(map.into_iter().eq(vec![(0, 0), (2, 20), (4, 40), (6, 60)]));
    Run
    │ │ │ │ -
    1.11.0 · source

    pub fn append(&mut self, other: &mut Self)
    where │ │ │ │ - K: Ord, │ │ │ │ - A: Clone,

    Moves all elements from other into self, leaving other empty.

    │ │ │ │ +
    1.11.0 · source

    pub fn append(&mut self, other: &mut Self)
    where │ │ │ │ + K: Ord, │ │ │ │ + A: Clone,

    Moves all elements from other into self, leaving other empty.

    │ │ │ │

    If a key from other is already present in self, the respective │ │ │ │ value from self will be overwritten with the respective value from other.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut a = BTreeMap::new();
│ │ │ │  a.insert(1, "a");
│ │ │ │ @@ -367,17 +367,17 @@
│ │ │ │  
│ │ │ │  assert_eq!(a[&1], "a");
│ │ │ │  assert_eq!(a[&2], "b");
│ │ │ │  assert_eq!(a[&3], "d"); // Note: "c" has been overwritten.
│ │ │ │  assert_eq!(a[&4], "e");
│ │ │ │  assert_eq!(a[&5], "f");
    Run
    │ │ │ │
    1.17.0 · source

    pub fn range<T, R>(&self, range: R) -> Range<'_, K, V> ⓘ
    where │ │ │ │ - T: Ord + ?Sized, │ │ │ │ - K: Borrow<T> + Ord, │ │ │ │ - R: RangeBounds<T>,

    Constructs a double-ended iterator over a sub-range of elements in the map. │ │ │ │ + T: Ord + ?Sized, │ │ │ │ + K: Borrow<T> + Ord, │ │ │ │ + R: RangeBounds<T>,

    Constructs a double-ended iterator over a sub-range of elements in the map. │ │ │ │ The simplest way is to use the range syntax min..max, thus range(min..max) will │ │ │ │ yield elements from min (inclusive) to max (exclusive). │ │ │ │ The range may also be entered as (Bound<T>, Bound<T>), so for example │ │ │ │ range((Excluded(4), Included(10))) will yield a left-exclusive, right-inclusive │ │ │ │ range from 4 to 10.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if range start > end. │ │ │ │ @@ -391,17 +391,17 @@ │ │ │ │ map.insert(5, "b"); │ │ │ │ map.insert(8, "c"); │ │ │ │ for (&key, &value) in map.range((Included(&4), Included(&8))) { │ │ │ │ println!("{key}: {value}"); │ │ │ │ } │ │ │ │ assert_eq!(Some((&5, &"b")), map.range(4..).next());Run

    │ │ │ │
    1.17.0 · source

    pub fn range_mut<T, R>(&mut self, range: R) -> RangeMut<'_, K, V> ⓘ
    where │ │ │ │ - T: Ord + ?Sized, │ │ │ │ - K: Borrow<T> + Ord, │ │ │ │ - R: RangeBounds<T>,

    Constructs a mutable double-ended iterator over a sub-range of elements in the map. │ │ │ │ + T: Ord + ?Sized, │ │ │ │ + K: Borrow<T> + Ord, │ │ │ │ + R: RangeBounds<T>,

    Constructs a mutable double-ended iterator over a sub-range of elements in the map. │ │ │ │ The simplest way is to use the range syntax min..max, thus range(min..max) will │ │ │ │ yield elements from min (inclusive) to max (exclusive). │ │ │ │ The range may also be entered as (Bound<T>, Bound<T>), so for example │ │ │ │ range((Excluded(4), Included(10))) will yield a left-exclusive, right-inclusive │ │ │ │ range from 4 to 10.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if range start > end. │ │ │ │ @@ -414,31 +414,31 @@ │ │ │ │ for (_, balance) in map.range_mut("B".."Cheryl") { │ │ │ │ *balance += 100; │ │ │ │ } │ │ │ │ for (name, balance) in &map { │ │ │ │ println!("{name} => {balance}"); │ │ │ │ }Run

    │ │ │ │
    source

    pub fn entry(&mut self, key: K) -> Entry<'_, K, V, A>
    where │ │ │ │ - K: Ord,

    Gets the given key’s corresponding entry in the map for in-place manipulation.

    │ │ │ │ + K: Ord,

    Gets the given key’s corresponding entry in the map for in-place manipulation.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut count: BTreeMap<&str, usize> = BTreeMap::new();
│ │ │ │  
│ │ │ │  // count the number of occurrences of letters in the vec
│ │ │ │  for x in ["a", "b", "a", "c", "a", "b"] {
│ │ │ │      count.entry(x).and_modify(|curr| *curr += 1).or_insert(1);
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(count["a"], 3);
│ │ │ │  assert_eq!(count["b"], 2);
│ │ │ │  assert_eq!(count["c"], 1);
    Run
    │ │ │ │ -
    1.11.0 · source

    pub fn split_off<Q: ?Sized + Ord>(&mut self, key: &Q) -> Self
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - A: Clone,

    Splits the collection into two at the given key. Returns everything after the given key, │ │ │ │ +

    1.11.0 · source

    pub fn split_off<Q: ?Sized + Ord>(&mut self, key: &Q) -> Self
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + A: Clone,

    Splits the collection into two at the given key. Returns everything after the given key, │ │ │ │ including the key.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut a = BTreeMap::new();
│ │ │ │  a.insert(1, "a");
│ │ │ │  a.insert(2, "b");
│ │ │ │ @@ -454,16 +454,16 @@
│ │ │ │  assert_eq!(a[&1], "a");
│ │ │ │  assert_eq!(a[&2], "b");
│ │ │ │  
│ │ │ │  assert_eq!(b[&3], "c");
│ │ │ │  assert_eq!(b[&17], "d");
│ │ │ │  assert_eq!(b[&41], "e");
    Run
    │ │ │ │
    source

    pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, K, V, F, A> ⓘ
    where │ │ │ │ - K: Ord, │ │ │ │ - F: FnMut(&K, &mut V) -> bool,

    🔬This is a nightly-only experimental API. (btree_extract_if #70530)

    Creates an iterator that visits all elements (key-value pairs) in │ │ │ │ + K: Ord, │ │ │ │ + F: FnMut(&K, &mut V) -> bool,

    🔬This is a nightly-only experimental API. (btree_extract_if #70530)

    Creates an iterator that visits all elements (key-value pairs) in │ │ │ │ ascending key order and uses a closure to determine if an element should │ │ │ │ be removed. If the closure returns true, the element is removed from │ │ │ │ the map and yielded. If the closure returns false, or panics, the │ │ │ │ element remains in the map and will not be yielded.

    │ │ │ │

    The iterator also lets you mutate the value of each element in the │ │ │ │ closure, regardless of whether you choose to keep or remove it.

    │ │ │ │

    If the returned ExtractIf is not exhausted, e.g. because it is dropped without iterating │ │ │ │ @@ -500,15 +500,15 @@ │ │ │ │ │ │ │ │ let mut a = BTreeMap::new(); │ │ │ │ a.insert(1, "hello"); │ │ │ │ a.insert(2, "goodbye"); │ │ │ │ │ │ │ │ let values: Vec<&str> = a.into_values().collect(); │ │ │ │ assert_eq!(values, ["hello", "goodbye"]);Run

    │ │ │ │ -
    source§

    impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A>

    source

    pub fn iter(&self) -> Iter<'_, K, V> ⓘ

    Gets an iterator over the entries of the map, sorted by key.

    │ │ │ │ +
    source§

    impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A>

    source

    pub fn iter(&self) -> Iter<'_, K, V> ⓘ

    Gets an iterator over the entries of the map, sorted by key.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map = BTreeMap::new();
│ │ │ │  map.insert(3, "c");
│ │ │ │  map.insert(2, "b");
│ │ │ │  map.insert(1, "a");
│ │ │ │ @@ -566,33 +566,33 @@
│ │ │ │  for value in a.values_mut() {
│ │ │ │      value.push_str("!");
│ │ │ │  }
│ │ │ │  
│ │ │ │  let values: Vec<String> = a.values().cloned().collect();
│ │ │ │  assert_eq!(values, [String::from("hello!"),
│ │ │ │                      String::from("goodbye!")]);
    Run
    │ │ │ │ -
    const: unstable · source

    pub fn len(&self) -> usize

    Returns the number of elements in the map.

    │ │ │ │ +
    const: unstable · source

    pub fn len(&self) -> usize

    Returns the number of elements in the map.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut a = BTreeMap::new();
│ │ │ │  assert_eq!(a.len(), 0);
│ │ │ │  a.insert(1, "a");
│ │ │ │  assert_eq!(a.len(), 1);
    Run
    │ │ │ │ -
    const: unstable · source

    pub fn is_empty(&self) -> bool

    Returns true if the map contains no elements.

    │ │ │ │ +
    const: unstable · source

    pub fn is_empty(&self) -> bool

    Returns true if the map contains no elements.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut a = BTreeMap::new();
│ │ │ │  assert!(a.is_empty());
│ │ │ │  a.insert(1, "a");
│ │ │ │  assert!(!a.is_empty());
    Run
    │ │ │ │ -
    source

    pub fn lower_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a Cursor pointing at the gap before the smallest key │ │ │ │ +

    source

    pub fn lower_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a Cursor pointing at the gap before the smallest key │ │ │ │ greater than the given bound.

    │ │ │ │

    Passing Bound::Included(x) will return a cursor pointing to the │ │ │ │ gap before the smallest key greater than or equal to x.

    │ │ │ │

    Passing Bound::Excluded(x) will return a cursor pointing to the │ │ │ │ gap before the smallest key greater than x.

    │ │ │ │

    Passing Bound::Unbounded will return a cursor pointing to the │ │ │ │ gap before the smallest key in the map.

    │ │ │ │ @@ -616,17 +616,17 @@ │ │ │ │ let cursor = map.lower_bound(Bound::Excluded(&2)); │ │ │ │ assert_eq!(cursor.peek_prev(), Some((&2, &"b"))); │ │ │ │ assert_eq!(cursor.peek_next(), Some((&3, &"c"))); │ │ │ │ │ │ │ │ let cursor = map.lower_bound(Bound::Unbounded); │ │ │ │ assert_eq!(cursor.peek_prev(), None); │ │ │ │ assert_eq!(cursor.peek_next(), Some((&1, &"a")));Run
    │ │ │ │ -
    source

    pub fn lower_bound_mut<Q>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, K, V, A>
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a CursorMut pointing at the gap before the smallest key │ │ │ │ +

    source

    pub fn lower_bound_mut<Q>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, K, V, A>
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a CursorMut pointing at the gap before the smallest key │ │ │ │ greater than the given bound.

    │ │ │ │

    Passing Bound::Included(x) will return a cursor pointing to the │ │ │ │ gap before the smallest key greater than or equal to x.

    │ │ │ │

    Passing Bound::Excluded(x) will return a cursor pointing to the │ │ │ │ gap before the smallest key greater than x.

    │ │ │ │

    Passing Bound::Unbounded will return a cursor pointing to the │ │ │ │ gap before the smallest key in the map.

    │ │ │ │ @@ -650,17 +650,17 @@ │ │ │ │ let mut cursor = map.lower_bound_mut(Bound::Excluded(&2)); │ │ │ │ assert_eq!(cursor.peek_prev(), Some((&2, &mut "b"))); │ │ │ │ assert_eq!(cursor.peek_next(), Some((&3, &mut "c"))); │ │ │ │ │ │ │ │ let mut cursor = map.lower_bound_mut(Bound::Unbounded); │ │ │ │ assert_eq!(cursor.peek_prev(), None); │ │ │ │ assert_eq!(cursor.peek_next(), Some((&1, &mut "a")));Run
    │ │ │ │ -
    source

    pub fn upper_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a Cursor pointing at the gap after the greatest key │ │ │ │ +

    source

    pub fn upper_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a Cursor pointing at the gap after the greatest key │ │ │ │ smaller than the given bound.

    │ │ │ │

    Passing Bound::Included(x) will return a cursor pointing to the │ │ │ │ gap after the greatest key smaller than or equal to x.

    │ │ │ │

    Passing Bound::Excluded(x) will return a cursor pointing to the │ │ │ │ gap after the greatest key smaller than x.

    │ │ │ │

    Passing Bound::Unbounded will return a cursor pointing to the │ │ │ │ gap after the greatest key in the map.

    │ │ │ │ @@ -684,17 +684,17 @@ │ │ │ │ let cursor = map.upper_bound(Bound::Excluded(&3)); │ │ │ │ assert_eq!(cursor.peek_prev(), Some((&2, &"b"))); │ │ │ │ assert_eq!(cursor.peek_next(), Some((&3, &"c"))); │ │ │ │ │ │ │ │ let cursor = map.upper_bound(Bound::Unbounded); │ │ │ │ assert_eq!(cursor.peek_prev(), Some((&4, &"d"))); │ │ │ │ assert_eq!(cursor.peek_next(), None);Run
    │ │ │ │ -
    source

    pub fn upper_bound_mut<Q>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, K, V, A>
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a CursorMut pointing at the gap after the greatest key │ │ │ │ +

    source

    pub fn upper_bound_mut<Q>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, K, V, A>
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a CursorMut pointing at the gap after the greatest key │ │ │ │ smaller than the given bound.

    │ │ │ │

    Passing Bound::Included(x) will return a cursor pointing to the │ │ │ │ gap after the greatest key smaller than or equal to x.

    │ │ │ │

    Passing Bound::Excluded(x) will return a cursor pointing to the │ │ │ │ gap after the greatest key smaller than x.

    │ │ │ │

    Passing Bound::Unbounded will return a cursor pointing to the │ │ │ │ gap after the greatest key in the map.

    │ │ │ │ @@ -718,55 +718,55 @@ │ │ │ │ let mut cursor = map.upper_bound_mut(Bound::Excluded(&3)); │ │ │ │ assert_eq!(cursor.peek_prev(), Some((&2, &mut "b"))); │ │ │ │ assert_eq!(cursor.peek_next(), Some((&3, &mut "c"))); │ │ │ │ │ │ │ │ let mut cursor = map.upper_bound_mut(Bound::Unbounded); │ │ │ │ assert_eq!(cursor.peek_prev(), Some((&4, &mut "d"))); │ │ │ │ assert_eq!(cursor.peek_next(), None);Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K: Clone, V: Clone, A: Allocator + Clone> Clone for BTreeMap<K, V, A>

    source§

    fn clone(&self) -> BTreeMap<K, V, A>

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for BTreeMap<K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<K, V> Default for BTreeMap<K, V>

    source§

    fn default() -> BTreeMap<K, V>

    Creates an empty BTreeMap.

    │ │ │ │ -
    1.7.0 · source§

    impl<K, V, A: Allocator + Clone> Drop for BTreeMap<K, V, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.2.0 · source§

    impl<'a, K: Ord + Copy, V: Copy, A: Allocator + Clone> Extend<(&'a K, &'a V)> for BTreeMap<K, V, A>

    source§

    fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, (k, v): (&'a K, &'a V))

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl<K: Ord, V, A: Allocator + Clone> Extend<(K, V)> for BTreeMap<K, V, A>

    source§

    fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, (k, v): (K, V))

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.56.0 · source§

    impl<K: Ord, V, const N: usize> From<[(K, V); N]> for BTreeMap<K, V>

    source§

    fn from(arr: [(K, V); N]) -> Self

    Converts a [(K, V); N] into a BTreeMap<(K, V)>.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<K: Clone, V: Clone, A: Allocator + Clone> Clone for BTreeMap<K, V, A>

    source§

    fn clone(&self) -> BTreeMap<K, V, A>

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for BTreeMap<K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<K, V> Default for BTreeMap<K, V>

    source§

    fn default() -> BTreeMap<K, V>

    Creates an empty BTreeMap.

    │ │ │ │ +
    1.7.0 · source§

    impl<K, V, A: Allocator + Clone> Drop for BTreeMap<K, V, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.2.0 · source§

    impl<'a, K: Ord + Copy, V: Copy, A: Allocator + Clone> Extend<(&'a K, &'a V)> for BTreeMap<K, V, A>

    source§

    fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, (k, v): (&'a K, &'a V))

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl<K: Ord, V, A: Allocator + Clone> Extend<(K, V)> for BTreeMap<K, V, A>

    source§

    fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, (k, v): (K, V))

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.56.0 · source§

    impl<K: Ord, V, const N: usize> From<[(K, V); N]> for BTreeMap<K, V>

    source§

    fn from(arr: [(K, V); N]) -> Self

    Converts a [(K, V); N] into a BTreeMap<(K, V)>.

    │ │ │ │ │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let map1 = BTreeMap::from([(1, 2), (3, 4)]);
│ │ │ │  let map2: BTreeMap<_, _> = [(1, 2), (3, 4)].into();
│ │ │ │  assert_eq!(map1, map2);
    Run
    │ │ │ │ -
    source§

    impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V>

    source§

    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> BTreeMap<K, V>

    Creates a value from an iterator. Read more
    source§

    impl<K: Hash, V: Hash, A: Allocator + Clone> Hash for BTreeMap<K, V, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ - H: Hasher, │ │ │ │ - Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<K, Q, V, A: Allocator + Clone> Index<&Q> for BTreeMap<K, V, A>
    where │ │ │ │ - K: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    source§

    fn index(&self, key: &Q) -> &V

    Returns a reference to the value corresponding to the supplied key.

    │ │ │ │ +
    source§

    impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V>

    source§

    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> BTreeMap<K, V>

    Creates a value from an iterator. Read more
    source§

    impl<K: Hash, V: Hash, A: Allocator + Clone> Hash for BTreeMap<K, V, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ + H: Hasher, │ │ │ │ + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<K, Q, V, A: Allocator + Clone> Index<&Q> for BTreeMap<K, V, A>
    where │ │ │ │ + K: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    source§

    fn index(&self, key: &Q) -> &V

    Returns a reference to the value corresponding to the supplied key.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if the key is not present in the BTreeMap.

    │ │ │ │ -
    §

    type Output = V

    The returned type after indexing.
    source§

    impl<'a, K, V, A: Allocator + Clone> IntoIterator for &'a BTreeMap<K, V, A>

    §

    type Item = (&'a K, &'a V)

    The type of the elements being iterated over.
    §

    type IntoIter = Iter<'a, K, V>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Iter<'a, K, V> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<'a, K, V, A: Allocator + Clone> IntoIterator for &'a mut BTreeMap<K, V, A>

    §

    type Item = (&'a K, &'a mut V)

    The type of the elements being iterated over.
    §

    type IntoIter = IterMut<'a, K, V>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> IterMut<'a, K, V> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<K, V, A: Allocator + Clone> IntoIterator for BTreeMap<K, V, A>

    §

    type Item = (K, V)

    The type of the elements being iterated over.
    §

    type IntoIter = IntoIter<K, V, A>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> IntoIter<K, V, A> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<K: Ord, V: Ord, A: Allocator + Clone> Ord for BTreeMap<K, V, A>

    source§

    fn cmp(&self, other: &BTreeMap<K, V, A>) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ - Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<K: PartialEq, V: PartialEq, A: Allocator + Clone> PartialEq for BTreeMap<K, V, A>

    source§

    fn eq(&self, other: &BTreeMap<K, V, A>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<K: PartialOrd, V: PartialOrd, A: Allocator + Clone> PartialOrd for BTreeMap<K, V, A>

    source§

    fn partial_cmp(&self, other: &BTreeMap<K, V, A>) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ -operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ -operator. Read more
    source§

    impl<K: Eq, V: Eq, A: Allocator + Clone> Eq for BTreeMap<K, V, A>

    1.64.0 · source§

    impl<K, V, A> UnwindSafe for BTreeMap<K, V, A>
    where │ │ │ │ - A: UnwindSafe + Allocator + Clone, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    Auto Trait Implementations§

    §

    impl<K, V, A> Freeze for BTreeMap<K, V, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<K, V, A> RefUnwindSafe for BTreeMap<K, V, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<K, V, A> Send for BTreeMap<K, V, A>
    where │ │ │ │ - A: Send, │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<K, V, A> Sync for BTreeMap<K, V, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<K, V, A> Unpin for BTreeMap<K, V, A>
    where │ │ │ │ - A: Unpin,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +
    §

    type Output = V

    The returned type after indexing.
    source§

    impl<'a, K, V, A: Allocator + Clone> IntoIterator for &'a BTreeMap<K, V, A>

    §

    type Item = (&'a K, &'a V)

    The type of the elements being iterated over.
    §

    type IntoIter = Iter<'a, K, V>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Iter<'a, K, V> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<'a, K, V, A: Allocator + Clone> IntoIterator for &'a mut BTreeMap<K, V, A>

    §

    type Item = (&'a K, &'a mut V)

    The type of the elements being iterated over.
    §

    type IntoIter = IterMut<'a, K, V>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> IterMut<'a, K, V> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<K, V, A: Allocator + Clone> IntoIterator for BTreeMap<K, V, A>

    §

    type Item = (K, V)

    The type of the elements being iterated over.
    §

    type IntoIter = IntoIter<K, V, A>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> IntoIter<K, V, A> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<K: Ord, V: Ord, A: Allocator + Clone> Ord for BTreeMap<K, V, A>

    source§

    fn cmp(&self, other: &BTreeMap<K, V, A>) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ + Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<K: PartialEq, V: PartialEq, A: Allocator + Clone> PartialEq for BTreeMap<K, V, A>

    source§

    fn eq(&self, other: &BTreeMap<K, V, A>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<K: PartialOrd, V: PartialOrd, A: Allocator + Clone> PartialOrd for BTreeMap<K, V, A>

    source§

    fn partial_cmp(&self, other: &BTreeMap<K, V, A>) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ +operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ +operator. Read more
    source§

    impl<K: Eq, V: Eq, A: Allocator + Clone> Eq for BTreeMap<K, V, A>

    1.64.0 · source§

    impl<K, V, A> UnwindSafe for BTreeMap<K, V, A>
    where │ │ │ │ + A: UnwindSafe + Allocator + Clone, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    Auto Trait Implementations§

    §

    impl<K, V, A> Freeze for BTreeMap<K, V, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<K, V, A> RefUnwindSafe for BTreeMap<K, V, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<K, V, A> Send for BTreeMap<K, V, A>
    where │ │ │ │ + A: Send, │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<K, V, A> Sync for BTreeMap<K, V, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<K, V, A> Unpin for BTreeMap<K, V, A>
    where │ │ │ │ + A: Unpin,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Cursor.html │ │ │ │ @@ -1,40 +1,40 @@ │ │ │ │ Cursor in alloc::collections::btree_map - Rust
    │ │ │ │

    Struct alloc::collections::btree_map::Cursor

    source · 
    pub struct Cursor<'a, K: 'a, V: 'a> { /* private fields */ }
    🔬This is a nightly-only experimental API. (btree_cursors #107540)
    Expand description

    A cursor over a BTreeMap.

    │ │ │ │

    A Cursor is like an iterator, except that it can freely seek back-and-forth.

    │ │ │ │

    Cursors always point to a gap between two elements in the map, and can │ │ │ │ operate on the two immediately adjacent elements.

    │ │ │ │

    A Cursor is created with the BTreeMap::lower_bound and BTreeMap::upper_bound methods.

    │ │ │ │ -

    Implementations§

    source§

    impl<'a, K, V> Cursor<'a, K, V>

    source

    pub fn next(&mut self) -> Option<(&'a K, &'a V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the next gap, returning the key and value of the │ │ │ │ +

    Implementations§

    source§

    impl<'a, K, V> Cursor<'a, K, V>

    source

    pub fn next(&mut self) -> Option<(&'a K, &'a V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the next gap, returning the key and value of the │ │ │ │ element that it moved over.

    │ │ │ │

    If the cursor is already at the end of the map then None is returned │ │ │ │ and the cursor is not moved.

    │ │ │ │ -
    source

    pub fn prev(&mut self) -> Option<(&'a K, &'a V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the previous gap, returning the key and value of │ │ │ │ +

    source

    pub fn prev(&mut self) -> Option<(&'a K, &'a V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the previous gap, returning the key and value of │ │ │ │ the element that it moved over.

    │ │ │ │

    If the cursor is already at the start of the map then None is returned │ │ │ │ and the cursor is not moved.

    │ │ │ │ -
    source

    pub fn peek_next(&self) -> Option<(&'a K, &'a V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the next element without │ │ │ │ +

    source

    pub fn peek_next(&self) -> Option<(&'a K, &'a V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the next element without │ │ │ │ moving the cursor.

    │ │ │ │

    If the cursor is at the end of the map then None is returned

    │ │ │ │ -
    source

    pub fn peek_prev(&self) -> Option<(&'a K, &'a V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the previous element │ │ │ │ +

    source

    pub fn peek_prev(&self) -> Option<(&'a K, &'a V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the previous element │ │ │ │ without moving the cursor.

    │ │ │ │

    If the cursor is at the start of the map then None is returned.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K, V> Clone for Cursor<'_, K, V>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<K: Debug, V: Debug> Debug for Cursor<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for Cursor<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for Cursor<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for Cursor<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Sync for Cursor<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Unpin for Cursor<'a, K, V>

    §

    impl<'a, K, V> UnwindSafe for Cursor<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<K, V> Clone for Cursor<'_, K, V>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<K: Debug, V: Debug> Debug for Cursor<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for Cursor<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for Cursor<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for Cursor<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Sync for Cursor<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Unpin for Cursor<'a, K, V>

    §

    impl<'a, K, V> UnwindSafe for Cursor<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.CursorMut.html │ │ │ │ @@ -4,26 +4,26 @@ │ │ │ │ safely mutate the map during iteration. This is because the lifetime of its yielded │ │ │ │ references is tied to its own lifetime, instead of just the underlying map. This means │ │ │ │ cursors cannot yield multiple elements at once.

    │ │ │ │

    Cursors always point to a gap between two elements in the map, and can │ │ │ │ operate on the two immediately adjacent elements.

    │ │ │ │

    A CursorMut is created with the BTreeMap::lower_bound_mut and BTreeMap::upper_bound_mut │ │ │ │ methods.

    │ │ │ │ -

    Implementations§

    source§

    impl<'a, K, V, A> CursorMut<'a, K, V, A>

    source

    pub fn next(&mut self) -> Option<(&K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the next gap, returning the key and value of the │ │ │ │ +

    Implementations§

    source§

    impl<'a, K, V, A> CursorMut<'a, K, V, A>

    source

    pub fn next(&mut self) -> Option<(&K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the next gap, returning the key and value of the │ │ │ │ element that it moved over.

    │ │ │ │

    If the cursor is already at the end of the map then None is returned │ │ │ │ and the cursor is not moved.

    │ │ │ │ -
    source

    pub fn prev(&mut self) -> Option<(&K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the previous gap, returning the key and value of │ │ │ │ +

    source

    pub fn prev(&mut self) -> Option<(&K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the previous gap, returning the key and value of │ │ │ │ the element that it moved over.

    │ │ │ │

    If the cursor is already at the start of the map then None is returned │ │ │ │ and the cursor is not moved.

    │ │ │ │ -
    source

    pub fn peek_next(&mut self) -> Option<(&K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the next element without │ │ │ │ +

    source

    pub fn peek_next(&mut self) -> Option<(&K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the next element without │ │ │ │ moving the cursor.

    │ │ │ │

    If the cursor is at the end of the map then None is returned

    │ │ │ │ -
    source

    pub fn peek_prev(&mut self) -> Option<(&K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the previous element │ │ │ │ +

    source

    pub fn peek_prev(&mut self) -> Option<(&K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the previous element │ │ │ │ without moving the cursor.

    │ │ │ │

    If the cursor is at the start of the map then None is returned.

    │ │ │ │
    source

    pub fn as_cursor(&self) -> Cursor<'_, K, V>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a read-only cursor pointing to the same location as the │ │ │ │ CursorMut.

    │ │ │ │

    The lifetime of the returned Cursor is bound to that of the │ │ │ │ CursorMut, which means it cannot outlive the CursorMut and that the │ │ │ │ CursorMut is frozen for the lifetime of the Cursor.

    │ │ │ │ @@ -32,15 +32,15 @@ │ │ │ │
    §Safety
    │ │ │ │

    Since this cursor allows mutating keys, you must ensure that the BTreeMap │ │ │ │ invariants are maintained. Specifically:

    │ │ │ │
      │ │ │ │
    • The key of the newly inserted element must be unique in the tree.
      • │ │ │ │
    • All keys in the tree must remain in sorted order.
      • │ │ │ │
    │ │ │ │ -
    source§

    impl<'a, K: Ord, V, A: Allocator + Clone> CursorMut<'a, K, V, A>

    source

    pub unsafe fn insert_after_unchecked(&mut self, key: K, value: V)

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ +

    source§

    impl<'a, K: Ord, V, A: Allocator + Clone> CursorMut<'a, K, V, A>

    source

    pub unsafe fn insert_after_unchecked(&mut self, key: K, value: V)

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ cursor is currently pointing to.

    │ │ │ │

    After the insertion the cursor will be pointing at the gap after the │ │ │ │ newly inserted element.

    │ │ │ │
    §Safety
    │ │ │ │

    You must ensure that the BTreeMap invariants are maintained. │ │ │ │ Specifically:

    │ │ │ │
      │ │ │ │ @@ -58,53 +58,53 @@ │ │ │ │
    • The key of the newly inserted element must be unique in the tree.
      • │ │ │ │
    • All keys in the tree must remain in sorted order.
      • │ │ │ │
    │ │ │ │
    source

    pub fn insert_after( │ │ │ │ &mut self, │ │ │ │ key: K, │ │ │ │ value: V │ │ │ │ -) -> Result<(), UnorderedKeyError>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ +) -> Result<(), UnorderedKeyError>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ cursor is currently pointing to.

    │ │ │ │

    After the insertion the cursor will be pointing at the gap before the │ │ │ │ newly inserted element.

    │ │ │ │

    If the inserted key is not greater than the key before the cursor │ │ │ │ (if any), or if it not less than the key after the cursor (if any), │ │ │ │ then an UnorderedKeyError is returned since this would │ │ │ │ -invalidate the Ord invariant between the keys of the map.

    │ │ │ │ +invalidate the Ord invariant between the keys of the map.

    │ │ │ │
    source

    pub fn insert_before( │ │ │ │ &mut self, │ │ │ │ key: K, │ │ │ │ value: V │ │ │ │ -) -> Result<(), UnorderedKeyError>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ +) -> Result<(), UnorderedKeyError>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ cursor is currently pointing to.

    │ │ │ │

    After the insertion the cursor will be pointing at the gap after the │ │ │ │ newly inserted element.

    │ │ │ │

    If the inserted key is not greater than the key before the cursor │ │ │ │ (if any), or if it not less than the key after the cursor (if any), │ │ │ │ then an UnorderedKeyError is returned since this would │ │ │ │ -invalidate the Ord invariant between the keys of the map.

    │ │ │ │ -
    source

    pub fn remove_next(&mut self) -> Option<(K, V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Removes the next element from the BTreeMap.

    │ │ │ │ +invalidate the Ord invariant between the keys of the map.

    │ │ │ │ +
    source

    pub fn remove_next(&mut self) -> Option<(K, V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Removes the next element from the BTreeMap.

    │ │ │ │

    The element that was removed is returned. The cursor position is │ │ │ │ unchanged (before the removed element).

    │ │ │ │ -
    source

    pub fn remove_prev(&mut self) -> Option<(K, V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Removes the precending element from the BTreeMap.

    │ │ │ │ +
    source

    pub fn remove_prev(&mut self) -> Option<(K, V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Removes the precending element from the BTreeMap.

    │ │ │ │

    The element that was removed is returned. The cursor position is │ │ │ │ unchanged (after the removed element).

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K: Debug, V: Debug, A> Debug for CursorMut<'_, K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V, A> Freeze for CursorMut<'a, K, V, A>

    §

    impl<'a, K, V, A> RefUnwindSafe for CursorMut<'a, K, V, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V, A> Send for CursorMut<'a, K, V, A>
    where │ │ │ │ - A: Send, │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<'a, K, V, A> Sync for CursorMut<'a, K, V, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V, A> Unpin for CursorMut<'a, K, V, A>

    §

    impl<'a, K, V, A = Global> !UnwindSafe for CursorMut<'a, K, V, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<K: Debug, V: Debug, A> Debug for CursorMut<'_, K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V, A> Freeze for CursorMut<'a, K, V, A>

    §

    impl<'a, K, V, A> RefUnwindSafe for CursorMut<'a, K, V, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V, A> Send for CursorMut<'a, K, V, A>
    where │ │ │ │ + A: Send, │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<'a, K, V, A> Sync for CursorMut<'a, K, V, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V, A> Unpin for CursorMut<'a, K, V, A>

    §

    impl<'a, K, V, A = Global> !UnwindSafe for CursorMut<'a, K, V, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.CursorMutKey.html │ │ │ │ @@ -12,34 +12,34 @@ │ │ │ │

    §Safety

    │ │ │ │

    Since this cursor allows mutating keys, you must ensure that the BTreeMap │ │ │ │ invariants are maintained. Specifically:

    │ │ │ │
      │ │ │ │
    • The key of the newly inserted element must be unique in the tree.
      • │ │ │ │
    • All keys in the tree must remain in sorted order.
      • │ │ │ │
    │ │ │ │ -

    Implementations§

    source§

    impl<'a, K, V, A> CursorMutKey<'a, K, V, A>

    source

    pub fn next(&mut self) -> Option<(&mut K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the next gap, returning the key and value of the │ │ │ │ +

    Implementations§

    source§

    impl<'a, K, V, A> CursorMutKey<'a, K, V, A>

    source

    pub fn next(&mut self) -> Option<(&mut K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the next gap, returning the key and value of the │ │ │ │ element that it moved over.

    │ │ │ │

    If the cursor is already at the end of the map then None is returned │ │ │ │ and the cursor is not moved.

    │ │ │ │ -
    source

    pub fn prev(&mut self) -> Option<(&mut K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the previous gap, returning the key and value of │ │ │ │ +

    source

    pub fn prev(&mut self) -> Option<(&mut K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Advances the cursor to the previous gap, returning the key and value of │ │ │ │ the element that it moved over.

    │ │ │ │

    If the cursor is already at the start of the map then None is returned │ │ │ │ and the cursor is not moved.

    │ │ │ │ -
    source

    pub fn peek_next(&mut self) -> Option<(&mut K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the next element without │ │ │ │ +

    source

    pub fn peek_next(&mut self) -> Option<(&mut K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the next element without │ │ │ │ moving the cursor.

    │ │ │ │

    If the cursor is at the end of the map then None is returned

    │ │ │ │ -
    source

    pub fn peek_prev(&mut self) -> Option<(&mut K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the previous element │ │ │ │ +

    source

    pub fn peek_prev(&mut self) -> Option<(&mut K, &mut V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a reference to the key and value of the previous element │ │ │ │ without moving the cursor.

    │ │ │ │

    If the cursor is at the start of the map then None is returned.

    │ │ │ │
    source

    pub fn as_cursor(&self) -> Cursor<'_, K, V>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Returns a read-only cursor pointing to the same location as the │ │ │ │ CursorMutKey.

    │ │ │ │

    The lifetime of the returned Cursor is bound to that of the │ │ │ │ CursorMutKey, which means it cannot outlive the CursorMutKey and that the │ │ │ │ CursorMutKey is frozen for the lifetime of the Cursor.

    │ │ │ │ -
    source§

    impl<'a, K: Ord, V, A: Allocator + Clone> CursorMutKey<'a, K, V, A>

    source

    pub unsafe fn insert_after_unchecked(&mut self, key: K, value: V)

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ +

    source§

    impl<'a, K: Ord, V, A: Allocator + Clone> CursorMutKey<'a, K, V, A>

    source

    pub unsafe fn insert_after_unchecked(&mut self, key: K, value: V)

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ cursor is currently pointing to.

    │ │ │ │

    After the insertion the cursor will be pointing at the gap before the │ │ │ │ newly inserted element.

    │ │ │ │
    §Safety
    │ │ │ │

    You must ensure that the BTreeMap invariants are maintained. │ │ │ │ Specifically:

    │ │ │ │
      │ │ │ │ @@ -57,53 +57,53 @@ │ │ │ │
    • The key of the newly inserted element must be unique in the tree.
      • │ │ │ │
    • All keys in the tree must remain in sorted order.
      • │ │ │ │
    │ │ │ │
    source

    pub fn insert_after( │ │ │ │ &mut self, │ │ │ │ key: K, │ │ │ │ value: V │ │ │ │ -) -> Result<(), UnorderedKeyError>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ +) -> Result<(), UnorderedKeyError>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ cursor is currently pointing to.

    │ │ │ │

    After the insertion the cursor will be pointing at the gap before the │ │ │ │ newly inserted element.

    │ │ │ │

    If the inserted key is not greater than the key before the cursor │ │ │ │ (if any), or if it not less than the key after the cursor (if any), │ │ │ │ then an UnorderedKeyError is returned since this would │ │ │ │ -invalidate the Ord invariant between the keys of the map.

    │ │ │ │ +invalidate the Ord invariant between the keys of the map.

    │ │ │ │
    source

    pub fn insert_before( │ │ │ │ &mut self, │ │ │ │ key: K, │ │ │ │ value: V │ │ │ │ -) -> Result<(), UnorderedKeyError>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ +) -> Result<(), UnorderedKeyError>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Inserts a new key-value pair into the map in the gap that the │ │ │ │ cursor is currently pointing to.

    │ │ │ │

    After the insertion the cursor will be pointing at the gap after the │ │ │ │ newly inserted element.

    │ │ │ │

    If the inserted key is not greater than the key before the cursor │ │ │ │ (if any), or if it not less than the key after the cursor (if any), │ │ │ │ then an UnorderedKeyError is returned since this would │ │ │ │ -invalidate the Ord invariant between the keys of the map.

    │ │ │ │ -
    source

    pub fn remove_next(&mut self) -> Option<(K, V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Removes the next element from the BTreeMap.

    │ │ │ │ +invalidate the Ord invariant between the keys of the map.

    │ │ │ │ +
    source

    pub fn remove_next(&mut self) -> Option<(K, V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Removes the next element from the BTreeMap.

    │ │ │ │

    The element that was removed is returned. The cursor position is │ │ │ │ unchanged (before the removed element).

    │ │ │ │ -
    source

    pub fn remove_prev(&mut self) -> Option<(K, V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Removes the precending element from the BTreeMap.

    │ │ │ │ +
    source

    pub fn remove_prev(&mut self) -> Option<(K, V)>

    🔬This is a nightly-only experimental API. (btree_cursors #107540)

    Removes the precending element from the BTreeMap.

    │ │ │ │

    The element that was removed is returned. The cursor position is │ │ │ │ unchanged (after the removed element).

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K: Debug, V: Debug, A> Debug for CursorMutKey<'_, K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V, A> Freeze for CursorMutKey<'a, K, V, A>

    §

    impl<'a, K, V, A> RefUnwindSafe for CursorMutKey<'a, K, V, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V, A> Send for CursorMutKey<'a, K, V, A>
    where │ │ │ │ - A: Send, │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<'a, K, V, A> Sync for CursorMutKey<'a, K, V, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V, A> Unpin for CursorMutKey<'a, K, V, A>

    §

    impl<'a, K, V, A = Global> !UnwindSafe for CursorMutKey<'a, K, V, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<K: Debug, V: Debug, A> Debug for CursorMutKey<'_, K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V, A> Freeze for CursorMutKey<'a, K, V, A>

    §

    impl<'a, K, V, A> RefUnwindSafe for CursorMutKey<'a, K, V, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V, A> Send for CursorMutKey<'a, K, V, A>
    where │ │ │ │ + A: Send, │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<'a, K, V, A> Sync for CursorMutKey<'a, K, V, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V, A> Unpin for CursorMutKey<'a, K, V, A>

    §

    impl<'a, K, V, A = Global> !UnwindSafe for CursorMutKey<'a, K, V, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.ExtractIf.html │ │ │ │ @@ -1,213 +1,213 @@ │ │ │ │ ExtractIf in alloc::collections::btree_map - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_map::ExtractIf

    source · 
    pub struct ExtractIf<'a, K, V, F, A: Allocator + Clone = Global>
    where
│ │ │ │ -    F: 'a + FnMut(&K, &mut V) -> bool,
    { /* private fields */ }
    🔬This is a nightly-only experimental API. (btree_extract_if #70530)
    Expand description

    An iterator produced by calling extract_if on BTreeMap.

    │ │ │ │ +

    Struct alloc::collections::btree_map::ExtractIf

    source · 
    pub struct ExtractIf<'a, K, V, F, A: Allocator + Clone = Global>
    where
│ │ │ │ +    F: 'a + FnMut(&K, &mut V) -> bool,
    { /* private fields */ }
    🔬This is a nightly-only experimental API. (btree_extract_if #70530)
    Expand description

    An iterator produced by calling extract_if on BTreeMap.

    │ │ │ │

    Trait Implementations§

    source§

    impl<K, V, F> Debug for ExtractIf<'_, K, V, F>
    where │ │ │ │ K: Debug, │ │ │ │ V: Debug, │ │ │ │ - F: FnMut(&K, &mut V) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<K, V, F, A: Allocator + Clone> Iterator for ExtractIf<'_, K, V, F, A>
    where │ │ │ │ - F: FnMut(&K, &mut V) -> bool,

    §

    type Item = (K, V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(K, V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + F: FnMut(&K, &mut V) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<K, V, F, A: Allocator + Clone> Iterator for ExtractIf<'_, K, V, F, A>
    where │ │ │ │ + F: FnMut(&K, &mut V) -> bool,

    §

    type Item = (K, V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(K, V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<K, V, F> FusedIterator for ExtractIf<'_, K, V, F>
    where │ │ │ │ - F: FnMut(&K, &mut V) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, K, V, F, A> Freeze for ExtractIf<'a, K, V, F, A>
    where │ │ │ │ - A: Freeze, │ │ │ │ - F: Freeze,

    §

    impl<'a, K, V, F, A> RefUnwindSafe for ExtractIf<'a, K, V, F, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - F: RefUnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V, F, A> Send for ExtractIf<'a, K, V, F, A>
    where │ │ │ │ - A: Send, │ │ │ │ - F: Send, │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<'a, K, V, F, A> Sync for ExtractIf<'a, K, V, F, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - F: Sync, │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V, F, A> Unpin for ExtractIf<'a, K, V, F, A>
    where │ │ │ │ - A: Unpin, │ │ │ │ - F: Unpin,

    §

    impl<'a, K, V, F, A = Global> !UnwindSafe for ExtractIf<'a, K, V, F, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<K, V, F> FusedIterator for ExtractIf<'_, K, V, F>
    where │ │ │ │ + F: FnMut(&K, &mut V) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, K, V, F, A> Freeze for ExtractIf<'a, K, V, F, A>
    where │ │ │ │ + A: Freeze, │ │ │ │ + F: Freeze,

    §

    impl<'a, K, V, F, A> RefUnwindSafe for ExtractIf<'a, K, V, F, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + F: RefUnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V, F, A> Send for ExtractIf<'a, K, V, F, A>
    where │ │ │ │ + A: Send, │ │ │ │ + F: Send, │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<'a, K, V, F, A> Sync for ExtractIf<'a, K, V, F, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + F: Sync, │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V, F, A> Unpin for ExtractIf<'a, K, V, F, A>
    where │ │ │ │ + A: Unpin, │ │ │ │ + F: Unpin,

    §

    impl<'a, K, V, F, A = Global> !UnwindSafe for ExtractIf<'a, K, V, F, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IntoIter.html │ │ │ │ @@ -1,230 +1,230 @@ │ │ │ │ IntoIter in alloc::collections::btree_map - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_map::IntoIter

    1.0.0 · source · 
    pub struct IntoIter<K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An owning iterator over the entries of a BTreeMap.

    │ │ │ │ -

    This struct is created by the into_iter method on BTreeMap │ │ │ │ -(provided by the IntoIterator trait). See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    1.17.0 · source§

    impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for IntoIter<K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V, A> Default for IntoIter<K, V, A>
    where │ │ │ │ - A: Allocator + Default + Clone,

    source§

    fn default() -> Self

    Creates an empty btree_map::IntoIter.

    │ │ │ │ +

    Struct alloc::collections::btree_map::IntoIter

    1.0.0 · source · 
    pub struct IntoIter<K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An owning iterator over the entries of a BTreeMap.

    │ │ │ │ +

    This struct is created by the into_iter method on BTreeMap │ │ │ │ +(provided by the IntoIterator trait). See its documentation for more.

    │ │ │ │ +

    Trait Implementations§

    1.17.0 · source§

    impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for IntoIter<K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V, A> Default for IntoIter<K, V, A>
    where │ │ │ │ + A: Allocator + Default + Clone,

    source§

    fn default() -> Self

    Creates an empty btree_map::IntoIter.

    │ │ │ │ │ │ │ │ 
    let iter: btree_map::IntoIter<u8, u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoIter<K, V, A>

    source§

    fn next_back(&mut self) -> Option<(K, V)>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    1.7.0 · source§

    impl<K, V, A: Allocator + Clone> Drop for IntoIter<K, V, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    source§

    impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoIter<K, V, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<K, V, A: Allocator + Clone> Iterator for IntoIter<K, V, A>

    §

    type Item = (K, V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(K, V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoIter<K, V, A>

    source§

    fn next_back(&mut self) -> Option<(K, V)>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    1.7.0 · source§

    impl<K, V, A: Allocator + Clone> Drop for IntoIter<K, V, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    source§

    impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoIter<K, V, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<K, V, A: Allocator + Clone> Iterator for IntoIter<K, V, A>

    §

    type Item = (K, V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(K, V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<K, V, A: Allocator + Clone> FusedIterator for IntoIter<K, V, A>

    Auto Trait Implementations§

    §

    impl<K, V, A> Freeze for IntoIter<K, V, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<K, V, A> RefUnwindSafe for IntoIter<K, V, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<K, V, A> Send for IntoIter<K, V, A>
    where │ │ │ │ - A: Send, │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<K, V, A> Sync for IntoIter<K, V, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<K, V, A> Unpin for IntoIter<K, V, A>
    where │ │ │ │ - A: Unpin,

    §

    impl<K, V, A> UnwindSafe for IntoIter<K, V, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<K, V, A: Allocator + Clone> FusedIterator for IntoIter<K, V, A>

    Auto Trait Implementations§

    §

    impl<K, V, A> Freeze for IntoIter<K, V, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<K, V, A> RefUnwindSafe for IntoIter<K, V, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<K, V, A> Send for IntoIter<K, V, A>
    where │ │ │ │ + A: Send, │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<K, V, A> Sync for IntoIter<K, V, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<K, V, A> Unpin for IntoIter<K, V, A>
    where │ │ │ │ + A: Unpin,

    §

    impl<K, V, A> UnwindSafe for IntoIter<K, V, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IntoKeys.html │ │ │ │ @@ -1,231 +1,231 @@ │ │ │ │ IntoKeys in alloc::collections::btree_map - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_map::IntoKeys

    1.54.0 · source · 
    pub struct IntoKeys<K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An owning iterator over the keys of a BTreeMap.

    │ │ │ │ +

    Struct alloc::collections::btree_map::IntoKeys

    1.54.0 · source · 
    pub struct IntoKeys<K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An owning iterator over the keys of a BTreeMap.

    │ │ │ │

    This struct is created by the into_keys method on BTreeMap. │ │ │ │ See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K: Debug, V, A: Allocator + Clone> Debug for IntoKeys<K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V, A> Default for IntoKeys<K, V, A>
    where │ │ │ │ - A: Allocator + Default + Clone,

    source§

    fn default() -> Self

    Creates an empty btree_map::IntoKeys.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<K: Debug, V, A: Allocator + Clone> Debug for IntoKeys<K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V, A> Default for IntoKeys<K, V, A>
    where │ │ │ │ + A: Allocator + Default + Clone,

    source§

    fn default() -> Self

    Creates an empty btree_map::IntoKeys.

    │ │ │ │ │ │ │ │ 
    let iter: btree_map::IntoKeys<u8, u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoKeys<K, V, A>

    source§

    fn next_back(&mut self) -> Option<K>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoKeys<K, V, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<K, V, A: Allocator + Clone> Iterator for IntoKeys<K, V, A>

    §

    type Item = K

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<K>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<K>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<K>
    where │ │ │ │ - K: Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<K>
    where │ │ │ │ - K: Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoKeys<K, V, A>

    source§

    fn next_back(&mut self) -> Option<K>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoKeys<K, V, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<K, V, A: Allocator + Clone> Iterator for IntoKeys<K, V, A>

    §

    type Item = K

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<K>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<K>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<K>
    where │ │ │ │ + K: Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<K>
    where │ │ │ │ + K: Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<K, V, A: Allocator + Clone> FusedIterator for IntoKeys<K, V, A>

    Auto Trait Implementations§

    §

    impl<K, V, A> Freeze for IntoKeys<K, V, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<K, V, A> RefUnwindSafe for IntoKeys<K, V, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<K, V, A> Send for IntoKeys<K, V, A>
    where │ │ │ │ - A: Send, │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<K, V, A> Sync for IntoKeys<K, V, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<K, V, A> Unpin for IntoKeys<K, V, A>
    where │ │ │ │ - A: Unpin,

    §

    impl<K, V, A> UnwindSafe for IntoKeys<K, V, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<K, V, A: Allocator + Clone> FusedIterator for IntoKeys<K, V, A>

    Auto Trait Implementations§

    §

    impl<K, V, A> Freeze for IntoKeys<K, V, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<K, V, A> RefUnwindSafe for IntoKeys<K, V, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<K, V, A> Send for IntoKeys<K, V, A>
    where │ │ │ │ + A: Send, │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<K, V, A> Sync for IntoKeys<K, V, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<K, V, A> Unpin for IntoKeys<K, V, A>
    where │ │ │ │ + A: Unpin,

    §

    impl<K, V, A> UnwindSafe for IntoKeys<K, V, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IntoValues.html │ │ │ │ @@ -1,229 +1,229 @@ │ │ │ │ IntoValues in alloc::collections::btree_map - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_map::IntoValues

    1.54.0 · source · 
    pub struct IntoValues<K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An owning iterator over the values of a BTreeMap.

    │ │ │ │ +

    Struct alloc::collections::btree_map::IntoValues

    1.54.0 · source · 
    pub struct IntoValues<K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An owning iterator over the values of a BTreeMap.

    │ │ │ │

    This struct is created by the into_values method on BTreeMap. │ │ │ │ See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K, V: Debug, A: Allocator + Clone> Debug for IntoValues<K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V, A> Default for IntoValues<K, V, A>
    where │ │ │ │ - A: Allocator + Default + Clone,

    source§

    fn default() -> Self

    Creates an empty btree_map::IntoValues.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<K, V: Debug, A: Allocator + Clone> Debug for IntoValues<K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V, A> Default for IntoValues<K, V, A>
    where │ │ │ │ + A: Allocator + Default + Clone,

    source§

    fn default() -> Self

    Creates an empty btree_map::IntoValues.

    │ │ │ │ │ │ │ │ 
    let iter: btree_map::IntoValues<u8, u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoValues<K, V, A>

    source§

    fn next_back(&mut self) -> Option<V>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoValues<K, V, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<K, V, A: Allocator + Clone> Iterator for IntoValues<K, V, A>

    §

    type Item = V

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<V>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<V>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoValues<K, V, A>

    source§

    fn next_back(&mut self) -> Option<V>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoValues<K, V, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<K, V, A: Allocator + Clone> Iterator for IntoValues<K, V, A>

    §

    type Item = V

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<V>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<V>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<K, V, A: Allocator + Clone> FusedIterator for IntoValues<K, V, A>

    Auto Trait Implementations§

    §

    impl<K, V, A> Freeze for IntoValues<K, V, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<K, V, A> RefUnwindSafe for IntoValues<K, V, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<K, V, A> Send for IntoValues<K, V, A>
    where │ │ │ │ - A: Send, │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<K, V, A> Sync for IntoValues<K, V, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<K, V, A> Unpin for IntoValues<K, V, A>
    where │ │ │ │ - A: Unpin,

    §

    impl<K, V, A> UnwindSafe for IntoValues<K, V, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<K, V, A: Allocator + Clone> FusedIterator for IntoValues<K, V, A>

    Auto Trait Implementations§

    §

    impl<K, V, A> Freeze for IntoValues<K, V, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<K, V, A> RefUnwindSafe for IntoValues<K, V, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<K, V, A> Send for IntoValues<K, V, A>
    where │ │ │ │ + A: Send, │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<K, V, A> Sync for IntoValues<K, V, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<K, V, A> Unpin for IntoValues<K, V, A>
    where │ │ │ │ + A: Unpin,

    §

    impl<K, V, A> UnwindSafe for IntoValues<K, V, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Iter.html │ │ │ │ @@ -1,226 +1,226 @@ │ │ │ │ Iter in alloc::collections::btree_map - Rust
    │ │ │ │

    Struct alloc::collections::btree_map::Iter

    1.0.0 · source · 
    pub struct Iter<'a, K: 'a, V: 'a> { /* private fields */ }
    Expand description

    An iterator over the entries of a BTreeMap.

    │ │ │ │

    This struct is created by the iter method on BTreeMap. See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K, V> Clone for Iter<'_, K, V>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for Iter<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<'a, K: 'a, V: 'a> Default for Iter<'a, K, V>

    source§

    fn default() -> Self

    Creates an empty btree_map::Iter.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<K, V> Clone for Iter<'_, K, V>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for Iter<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<'a, K: 'a, V: 'a> Default for Iter<'a, K, V>

    source§

    fn default() -> Self

    Creates an empty btree_map::Iter.

    │ │ │ │ │ │ │ │ 
    let iter: btree_map::Iter<'_, u8, u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<'a, K: 'a, V: 'a> DoubleEndedIterator for Iter<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<(&'a K, &'a V)>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V> ExactSizeIterator for Iter<'_, K, V>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V>

    §

    type Item = (&'a K, &'a V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(&'a K, &'a V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<(&'a K, &'a V)>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<(&'a K, &'a V)>
    where │ │ │ │ - (&'a K, &'a V): Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<(&'a K, &'a V)>
    where │ │ │ │ - (&'a K, &'a V): Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<'a, K: 'a, V: 'a> DoubleEndedIterator for Iter<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<(&'a K, &'a V)>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V> ExactSizeIterator for Iter<'_, K, V>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V>

    §

    type Item = (&'a K, &'a V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(&'a K, &'a V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<(&'a K, &'a V)>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<(&'a K, &'a V)>
    where │ │ │ │ + (&'a K, &'a V): Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<(&'a K, &'a V)>
    where │ │ │ │ + (&'a K, &'a V): Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for Iter<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for Iter<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for Iter<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for Iter<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Sync for Iter<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Unpin for Iter<'a, K, V>

    §

    impl<'a, K, V> UnwindSafe for Iter<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for Iter<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for Iter<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for Iter<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for Iter<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Sync for Iter<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Unpin for Iter<'a, K, V>

    §

    impl<'a, K, V> UnwindSafe for Iter<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.IterMut.html │ │ │ │ @@ -1,222 +1,222 @@ │ │ │ │ IterMut in alloc::collections::btree_map - Rust
    │ │ │ │

    Struct alloc::collections::btree_map::IterMut

    1.0.0 · source · 
    pub struct IterMut<'a, K: 'a, V: 'a> { /* private fields */ }
    Expand description

    A mutable iterator over the entries of a BTreeMap.

    │ │ │ │

    This struct is created by the iter_mut method on BTreeMap. See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for IterMut<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<'a, K: 'a, V: 'a> Default for IterMut<'a, K, V>

    source§

    fn default() -> Self

    Creates an empty btree_map::IterMut.

    │ │ │ │ +

    Trait Implementations§

    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for IterMut<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<'a, K: 'a, V: 'a> Default for IterMut<'a, K, V>

    source§

    fn default() -> Self

    Creates an empty btree_map::IterMut.

    │ │ │ │ │ │ │ │ 
    let iter: btree_map::IterMut<'_, u8, u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<(&'a K, &'a mut V)>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V> ExactSizeIterator for IterMut<'_, K, V>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, K, V> Iterator for IterMut<'a, K, V>

    §

    type Item = (&'a K, &'a mut V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(&'a K, &'a mut V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<(&'a K, &'a mut V)>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<(&'a K, &'a mut V)>
    where │ │ │ │ - (&'a K, &'a mut V): Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<(&'a K, &'a mut V)>
    where │ │ │ │ - (&'a K, &'a mut V): Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<(&'a K, &'a mut V)>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V> ExactSizeIterator for IterMut<'_, K, V>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, K, V> Iterator for IterMut<'a, K, V>

    §

    type Item = (&'a K, &'a mut V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(&'a K, &'a mut V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<(&'a K, &'a mut V)>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<(&'a K, &'a mut V)>
    where │ │ │ │ + (&'a K, &'a mut V): Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<(&'a K, &'a mut V)>
    where │ │ │ │ + (&'a K, &'a mut V): Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for IterMut<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for IterMut<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for IterMut<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for IterMut<'a, K, V>
    where │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<'a, K, V> Sync for IterMut<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Unpin for IterMut<'a, K, V>

    §

    impl<'a, K, V> !UnwindSafe for IterMut<'a, K, V>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for IterMut<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for IterMut<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for IterMut<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for IterMut<'a, K, V>
    where │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<'a, K, V> Sync for IterMut<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Unpin for IterMut<'a, K, V>

    §

    impl<'a, K, V> !UnwindSafe for IterMut<'a, K, V>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Keys.html │ │ │ │ @@ -1,226 +1,226 @@ │ │ │ │ Keys in alloc::collections::btree_map - Rust
    │ │ │ │

    Struct alloc::collections::btree_map::Keys

    1.0.0 · source · 
    pub struct Keys<'a, K, V> { /* private fields */ }
    Expand description

    An iterator over the keys of a BTreeMap.

    │ │ │ │

    This struct is created by the keys method on BTreeMap. See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K, V> Clone for Keys<'_, K, V>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<K: Debug, V> Debug for Keys<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V> Default for Keys<'_, K, V>

    source§

    fn default() -> Self

    Creates an empty btree_map::Keys.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<K, V> Clone for Keys<'_, K, V>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<K: Debug, V> Debug for Keys<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V> Default for Keys<'_, K, V>

    source§

    fn default() -> Self

    Creates an empty btree_map::Keys.

    │ │ │ │ │ │ │ │ 
    let iter: btree_map::Keys<'_, u8, u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<&'a K>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V> ExactSizeIterator for Keys<'_, K, V>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, K, V> Iterator for Keys<'a, K, V>

    §

    type Item = &'a K

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a K>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a K>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<&'a K>
    where │ │ │ │ - &'a K: Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<&'a K>
    where │ │ │ │ - &'a K: Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<&'a K>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V> ExactSizeIterator for Keys<'_, K, V>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, K, V> Iterator for Keys<'a, K, V>

    §

    type Item = &'a K

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a K>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a K>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<&'a K>
    where │ │ │ │ + &'a K: Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<&'a K>
    where │ │ │ │ + &'a K: Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for Keys<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for Keys<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for Keys<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for Keys<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Sync for Keys<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Unpin for Keys<'a, K, V>

    §

    impl<'a, K, V> UnwindSafe for Keys<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for Keys<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for Keys<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for Keys<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for Keys<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Sync for Keys<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Unpin for Keys<'a, K, V>

    §

    impl<'a, K, V> UnwindSafe for Keys<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.OccupiedEntry.html │ │ │ │ @@ -1,44 +1,44 @@ │ │ │ │ OccupiedEntry in alloc::collections::btree_map - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_map::OccupiedEntry

    1.0.0 · source · 
    pub struct OccupiedEntry<'a, K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    A view into an occupied entry in a BTreeMap. │ │ │ │ +

    Struct alloc::collections::btree_map::OccupiedEntry

    1.0.0 · source · 
    pub struct OccupiedEntry<'a, K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    A view into an occupied entry in a BTreeMap. │ │ │ │ It is part of the Entry enum.

    │ │ │ │ -

    Implementations§

    source§

    impl<'a, K: Ord, V, A: Allocator + Clone> OccupiedEntry<'a, K, V, A>

    1.10.0 · source

    pub fn key(&self) -> &K

    Gets a reference to the key in the entry.

    │ │ │ │ +

    Implementations§

    source§

    impl<'a, K: Ord, V, A: Allocator + Clone> OccupiedEntry<'a, K, V, A>

    1.10.0 · source

    pub fn key(&self) -> &K

    Gets a reference to the key in the entry.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, usize> = BTreeMap::new();
│ │ │ │  map.entry("poneyland").or_insert(12);
│ │ │ │  assert_eq!(map.entry("poneyland").key(), &"poneyland");
    Run
    │ │ │ │ -
    1.12.0 · source

    pub fn remove_entry(self) -> (K, V)

    Take ownership of the key and value from the map.

    │ │ │ │ +
    1.12.0 · source

    pub fn remove_entry(self) -> (K, V)

    Take ownership of the key and value from the map.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  use std::collections::btree_map::Entry;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, usize> = BTreeMap::new();
│ │ │ │  map.entry("poneyland").or_insert(12);
│ │ │ │  
│ │ │ │  if let Entry::Occupied(o) = map.entry("poneyland") {
│ │ │ │      // We delete the entry from the map.
│ │ │ │      o.remove_entry();
│ │ │ │  }
│ │ │ │  
│ │ │ │  // If now try to get the value, it will panic:
│ │ │ │  // println!("{}", map["poneyland"]);
    Run
    │ │ │ │ -
    source

    pub fn get(&self) -> &V

    Gets a reference to the value in the entry.

    │ │ │ │ +
    source

    pub fn get(&self) -> &V

    Gets a reference to the value in the entry.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  use std::collections::btree_map::Entry;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, usize> = BTreeMap::new();
│ │ │ │  map.entry("poneyland").or_insert(12);
│ │ │ │  
│ │ │ │  if let Entry::Occupied(o) = map.entry("poneyland") {
│ │ │ │      assert_eq!(o.get(), &12);
│ │ │ │  }
    Run
    │ │ │ │ -
    source

    pub fn get_mut(&mut self) -> &mut V

    Gets a mutable reference to the value in the entry.

    │ │ │ │ +
    source

    pub fn get_mut(&mut self) -> &mut V

    Gets a mutable reference to the value in the entry.

    │ │ │ │

    If you need a reference to the OccupiedEntry that may outlive the │ │ │ │ destruction of the Entry value, see into_mut.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  use std::collections::btree_map::Entry;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, usize> = BTreeMap::new();
│ │ │ │ @@ -49,15 +49,15 @@
│ │ │ │      *o.get_mut() += 10;
│ │ │ │      assert_eq!(*o.get(), 22);
│ │ │ │  
│ │ │ │      // We can use the same Entry multiple times.
│ │ │ │      *o.get_mut() += 2;
│ │ │ │  }
│ │ │ │  assert_eq!(map["poneyland"], 24);
    Run
    │ │ │ │ -
    source

    pub fn into_mut(self) -> &'a mut V

    Converts the entry into a mutable reference to its value.

    │ │ │ │ +
    source

    pub fn into_mut(self) -> &'a mut V

    Converts the entry into a mutable reference to its value.

    │ │ │ │

    If you need multiple references to the OccupiedEntry, see get_mut.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  use std::collections::btree_map::Entry;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, usize> = BTreeMap::new();
│ │ │ │  map.entry("poneyland").or_insert(12);
│ │ │ │ @@ -89,29 +89,29 @@
│ │ │ │  map.entry("poneyland").or_insert(12);
│ │ │ │  
│ │ │ │  if let Entry::Occupied(o) = map.entry("poneyland") {
│ │ │ │      assert_eq!(o.remove(), 12);
│ │ │ │  }
│ │ │ │  // If we try to get "poneyland"'s value, it'll panic:
│ │ │ │  // println!("{}", map["poneyland"]);
    Run
    │ │ │ │ -

    Trait Implementations§

    1.12.0 · source§

    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedEntry<'_, K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V, A> Freeze for OccupiedEntry<'a, K, V, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<'a, K, V, A> RefUnwindSafe for OccupiedEntry<'a, K, V, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V, A> Send for OccupiedEntry<'a, K, V, A>
    where │ │ │ │ - A: Send, │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<'a, K, V, A> Sync for OccupiedEntry<'a, K, V, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V, A> Unpin for OccupiedEntry<'a, K, V, A>
    where │ │ │ │ - A: Unpin,

    §

    impl<'a, K, V, A = Global> !UnwindSafe for OccupiedEntry<'a, K, V, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    1.12.0 · source§

    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedEntry<'_, K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V, A> Freeze for OccupiedEntry<'a, K, V, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<'a, K, V, A> RefUnwindSafe for OccupiedEntry<'a, K, V, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V, A> Send for OccupiedEntry<'a, K, V, A>
    where │ │ │ │ + A: Send, │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<'a, K, V, A> Sync for OccupiedEntry<'a, K, V, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V, A> Unpin for OccupiedEntry<'a, K, V, A>
    where │ │ │ │ + A: Unpin,

    §

    impl<'a, K, V, A = Global> !UnwindSafe for OccupiedEntry<'a, K, V, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.OccupiedError.html │ │ │ │ @@ -1,33 +1,33 @@ │ │ │ │ OccupiedError in alloc::collections::btree_map - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_map::OccupiedError

    source · 
    pub struct OccupiedError<'a, K: 'a, V: 'a, A: Allocator + Clone = Global> {
│ │ │ │ +    
    Struct alloc::collections::btree_map::OccupiedError
    source · 
    pub struct OccupiedError<'a, K: 'a, V: 'a, A: Allocator + Clone = Global> {
│ │ │ │      pub entry: OccupiedEntry<'a, K, V, A>,
│ │ │ │      pub value: V,
│ │ │ │  }
    🔬This is a nightly-only experimental API. (map_try_insert #82766)
    Expand description
    The error returned by try_insert when the key already exists.
    
│ │ │ │  
    Contains the occupied entry, and the value that was not inserted.
    
│ │ │ │  
    Fields§
    §entry: OccupiedEntry<'a, K, V, A>
    🔬This is a nightly-only experimental API. (map_try_insert #82766)
    The entry in the map that was already occupied.
    
│ │ │ │  
    §value: V
    🔬This is a nightly-only experimental API. (map_try_insert #82766)
    The value which was not inserted, because the entry was already occupied.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedError<'_, K, V, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<'a, K: Debug + Ord, V: Debug, A: Allocator + Clone> Display for OccupiedError<'a, K, V, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<'a, K: Debug + Ord, V: Debug> Error for OccupiedError<'a, K, V>
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    1.30.0 · source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    1.0.0 · source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn provide<'a>(&'a self, request: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    Auto Trait Implementations§
    §
    impl<'a, K, V, A> Freeze for OccupiedError<'a, K, V, A>
    where
│ │ │ │ -    A: Freeze,
│ │ │ │ -    V: Freeze,
    §
    impl<'a, K, V, A> RefUnwindSafe for OccupiedError<'a, K, V, A>
    where
│ │ │ │ -    A: RefUnwindSafe,
│ │ │ │ -    K: RefUnwindSafe,
│ │ │ │ -    V: RefUnwindSafe,
    §
    impl<'a, K, V, A> Send for OccupiedError<'a, K, V, A>
    where
│ │ │ │ -    A: Send,
│ │ │ │ -    K: Send,
│ │ │ │ -    V: Send,
    §
    impl<'a, K, V, A> Sync for OccupiedError<'a, K, V, A>
    where
│ │ │ │ -    A: Sync,
│ │ │ │ -    K: Sync,
│ │ │ │ -    V: Sync,
    §
    impl<'a, K, V, A> Unpin for OccupiedError<'a, K, V, A>
    where
│ │ │ │ -    A: Unpin,
│ │ │ │ -    V: Unpin,
    §
    impl<'a, K, V, A = Global> !UnwindSafe for OccupiedError<'a, K, V, A>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedError<'_, K, V, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<'a, K: Debug + Ord, V: Debug, A: Allocator + Clone> Display for OccupiedError<'a, K, V, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<'a, K: Debug + Ord, V: Debug> Error for OccupiedError<'a, K, V>
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    1.30.0 · source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    1.0.0 · source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn provide<'a>(&'a self, request: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    Auto Trait Implementations§
    §
    impl<'a, K, V, A> Freeze for OccupiedError<'a, K, V, A>
    where
│ │ │ │ +    A: Freeze,
│ │ │ │ +    V: Freeze,
    §
    impl<'a, K, V, A> RefUnwindSafe for OccupiedError<'a, K, V, A>
    where
│ │ │ │ +    A: RefUnwindSafe,
│ │ │ │ +    K: RefUnwindSafe,
│ │ │ │ +    V: RefUnwindSafe,
    §
    impl<'a, K, V, A> Send for OccupiedError<'a, K, V, A>
    where
│ │ │ │ +    A: Send,
│ │ │ │ +    K: Send,
│ │ │ │ +    V: Send,
    §
    impl<'a, K, V, A> Sync for OccupiedError<'a, K, V, A>
    where
│ │ │ │ +    A: Sync,
│ │ │ │ +    K: Sync,
│ │ │ │ +    V: Sync,
    §
    impl<'a, K, V, A> Unpin for OccupiedError<'a, K, V, A>
    where
│ │ │ │ +    A: Unpin,
│ │ │ │ +    V: Unpin,
    §
    impl<'a, K, V, A = Global> !UnwindSafe for OccupiedError<'a, K, V, A>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │  
    source§
    impl<T> ToString for T
    where
│ │ │ │ -    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +    T: Display + ?Sized,
    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Range.html │ │ │ │ @@ -1,223 +1,223 @@ │ │ │ │ Range in alloc::collections::btree_map - Rust
    │ │ │ │

    Struct alloc::collections::btree_map::Range

    1.17.0 · source · 
    pub struct Range<'a, K: 'a, V: 'a> { /* private fields */ }
    Expand description

    An iterator over a sub-range of entries in a BTreeMap.

    │ │ │ │

    This struct is created by the range method on BTreeMap. See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K, V> Clone for Range<'_, K, V>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<K: Debug, V: Debug> Debug for Range<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V> Default for Range<'_, K, V>

    source§

    fn default() -> Self

    Creates an empty btree_map::Range.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<K, V> Clone for Range<'_, K, V>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<K: Debug, V: Debug> Debug for Range<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V> Default for Range<'_, K, V>

    source§

    fn default() -> Self

    Creates an empty btree_map::Range.

    │ │ │ │ │ │ │ │ 
    let iter: btree_map::Range<'_, u8, u8> = Default::default();
│ │ │ │  assert_eq!(iter.count(), 0);
    Run
    │ │ │ │ -
    source§

    impl<'a, K, V> DoubleEndedIterator for Range<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<(&'a K, &'a V)>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, K, V> Iterator for Range<'a, K, V>

    §

    type Item = (&'a K, &'a V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(&'a K, &'a V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn last(self) -> Option<(&'a K, &'a V)>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<(&'a K, &'a V)>
    where │ │ │ │ - (&'a K, &'a V): Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<(&'a K, &'a V)>
    where │ │ │ │ - (&'a K, &'a V): Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<'a, K, V> DoubleEndedIterator for Range<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<(&'a K, &'a V)>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, K, V> Iterator for Range<'a, K, V>

    §

    type Item = (&'a K, &'a V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(&'a K, &'a V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn last(self) -> Option<(&'a K, &'a V)>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<(&'a K, &'a V)>
    where │ │ │ │ + (&'a K, &'a V): Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<(&'a K, &'a V)>
    where │ │ │ │ + (&'a K, &'a V): Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for Range<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for Range<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for Range<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for Range<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Sync for Range<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Unpin for Range<'a, K, V>

    §

    impl<'a, K, V> UnwindSafe for Range<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for Range<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for Range<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for Range<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for Range<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Sync for Range<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Unpin for Range<'a, K, V>

    §

    impl<'a, K, V> UnwindSafe for Range<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.RangeMut.html │ │ │ │ @@ -1,215 +1,215 @@ │ │ │ │ RangeMut in alloc::collections::btree_map - Rust
    │ │ │ │

    Struct alloc::collections::btree_map::RangeMut

    1.17.0 · source · 
    pub struct RangeMut<'a, K: 'a, V: 'a> { /* private fields */ }
    Expand description

    A mutable iterator over a sub-range of entries in a BTreeMap.

    │ │ │ │

    This struct is created by the range_mut method on BTreeMap. See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K: Debug, V: Debug> Debug for RangeMut<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<(&'a K, &'a mut V)>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, K, V> Iterator for RangeMut<'a, K, V>

    §

    type Item = (&'a K, &'a mut V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(&'a K, &'a mut V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn last(self) -> Option<(&'a K, &'a mut V)>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<(&'a K, &'a mut V)>
    where │ │ │ │ - (&'a K, &'a mut V): Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<(&'a K, &'a mut V)>
    where │ │ │ │ - (&'a K, &'a mut V): Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    source§

    impl<K: Debug, V: Debug> Debug for RangeMut<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<(&'a K, &'a mut V)>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, K, V> Iterator for RangeMut<'a, K, V>

    §

    type Item = (&'a K, &'a mut V)

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<(&'a K, &'a mut V)>

    Advances the iterator and returns the next value. Read more
    source§

    fn last(self) -> Option<(&'a K, &'a mut V)>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<(&'a K, &'a mut V)>
    where │ │ │ │ + (&'a K, &'a mut V): Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<(&'a K, &'a mut V)>
    where │ │ │ │ + (&'a K, &'a mut V): Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for RangeMut<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for RangeMut<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for RangeMut<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for RangeMut<'a, K, V>
    where │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<'a, K, V> Sync for RangeMut<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Unpin for RangeMut<'a, K, V>

    §

    impl<'a, K, V> !UnwindSafe for RangeMut<'a, K, V>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for RangeMut<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for RangeMut<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for RangeMut<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for RangeMut<'a, K, V>
    where │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<'a, K, V> Sync for RangeMut<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Unpin for RangeMut<'a, K, V>

    §

    impl<'a, K, V> !UnwindSafe for RangeMut<'a, K, V>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.UnorderedKeyError.html │ │ │ │ @@ -1,19 +1,19 @@ │ │ │ │ UnorderedKeyError in alloc::collections::btree_map - Rust
    │ │ │ │

    Struct alloc::collections::btree_map::UnorderedKeyError

    source · 
    pub struct UnorderedKeyError {}
    🔬This is a nightly-only experimental API. (btree_cursors #107540)
    Expand description

    Error type returned by CursorMut::insert_before and │ │ │ │ CursorMut::insert_after if the key being inserted is not properly │ │ │ │ ordered with regards to adjacent keys.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl Clone for UnorderedKeyError

    source§

    fn clone(&self) -> UnorderedKeyError

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for UnorderedKeyError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl Display for UnorderedKeyError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl Error for UnorderedKeyError

    1.30.0 · source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl PartialEq for UnorderedKeyError

    source§

    fn eq(&self, other: &UnorderedKeyError) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for UnorderedKeyError

    source§

    impl StructuralPartialEq for UnorderedKeyError

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl Clone for UnorderedKeyError

    source§

    fn clone(&self) -> UnorderedKeyError

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for UnorderedKeyError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl Display for UnorderedKeyError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl Error for UnorderedKeyError

    1.30.0 · source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl PartialEq for UnorderedKeyError

    source§

    fn eq(&self, other: &UnorderedKeyError) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for UnorderedKeyError

    source§

    impl StructuralPartialEq for UnorderedKeyError

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.VacantEntry.html │ │ │ │ @@ -1,11 +1,11 @@ │ │ │ │ VacantEntry in alloc::collections::btree_map - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_map::VacantEntry

    1.0.0 · source · 
    pub struct VacantEntry<'a, K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    A view into a vacant entry in a BTreeMap. │ │ │ │ +

    Struct alloc::collections::btree_map::VacantEntry

    1.0.0 · source · 
    pub struct VacantEntry<'a, K, V, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    A view into a vacant entry in a BTreeMap. │ │ │ │ It is part of the Entry enum.

    │ │ │ │ -

    Implementations§

    source§

    impl<'a, K: Ord, V, A: Allocator + Clone> VacantEntry<'a, K, V, A>

    1.10.0 · source

    pub fn key(&self) -> &K

    Gets a reference to the key that would be used when inserting a value │ │ │ │ +

    Implementations§

    source§

    impl<'a, K: Ord, V, A: Allocator + Clone> VacantEntry<'a, K, V, A>

    1.10.0 · source

    pub fn key(&self) -> &K

    Gets a reference to the key that would be used when inserting a value │ │ │ │ through the VacantEntry.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, usize> = BTreeMap::new();
│ │ │ │  assert_eq!(map.entry("poneyland").key(), &"poneyland");
    Run
    │ │ │ │
    1.12.0 · source

    pub fn into_key(self) -> K

    Take ownership of the key.

    │ │ │ │ @@ -14,43 +14,43 @@ │ │ │ │ use std::collections::btree_map::Entry; │ │ │ │ │ │ │ │ let mut map: BTreeMap<&str, usize> = BTreeMap::new(); │ │ │ │ │ │ │ │ if let Entry::Vacant(v) = map.entry("poneyland") { │ │ │ │ v.into_key(); │ │ │ │ }Run
    │ │ │ │ -
    source

    pub fn insert(self, value: V) -> &'a mut V

    Sets the value of the entry with the VacantEntry’s key, │ │ │ │ +

    source

    pub fn insert(self, value: V) -> &'a mut V

    Sets the value of the entry with the VacantEntry’s key, │ │ │ │ and returns a mutable reference to it.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeMap;
│ │ │ │  use std::collections::btree_map::Entry;
│ │ │ │  
│ │ │ │  let mut map: BTreeMap<&str, u32> = BTreeMap::new();
│ │ │ │  
│ │ │ │  if let Entry::Vacant(o) = map.entry("poneyland") {
│ │ │ │      o.insert(37);
│ │ │ │  }
│ │ │ │  assert_eq!(map["poneyland"], 37);
    Run
    │ │ │ │ -

    Trait Implementations§

    1.12.0 · source§

    impl<K: Debug + Ord, V, A: Allocator + Clone> Debug for VacantEntry<'_, K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V, A> Freeze for VacantEntry<'a, K, V, A>
    where │ │ │ │ - A: Freeze, │ │ │ │ - K: Freeze,

    §

    impl<'a, K, V, A> RefUnwindSafe for VacantEntry<'a, K, V, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V, A> Send for VacantEntry<'a, K, V, A>
    where │ │ │ │ - A: Send, │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<'a, K, V, A> Sync for VacantEntry<'a, K, V, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V, A> Unpin for VacantEntry<'a, K, V, A>
    where │ │ │ │ - A: Unpin, │ │ │ │ - K: Unpin,

    §

    impl<'a, K, V, A = Global> !UnwindSafe for VacantEntry<'a, K, V, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    1.12.0 · source§

    impl<K: Debug + Ord, V, A: Allocator + Clone> Debug for VacantEntry<'_, K, V, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<'a, K, V, A> Freeze for VacantEntry<'a, K, V, A>
    where │ │ │ │ + A: Freeze, │ │ │ │ + K: Freeze,

    §

    impl<'a, K, V, A> RefUnwindSafe for VacantEntry<'a, K, V, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V, A> Send for VacantEntry<'a, K, V, A>
    where │ │ │ │ + A: Send, │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<'a, K, V, A> Sync for VacantEntry<'a, K, V, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V, A> Unpin for VacantEntry<'a, K, V, A>
    where │ │ │ │ + A: Unpin, │ │ │ │ + K: Unpin,

    §

    impl<'a, K, V, A = Global> !UnwindSafe for VacantEntry<'a, K, V, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.Values.html │ │ │ │ @@ -1,224 +1,224 @@ │ │ │ │ Values in alloc::collections::btree_map - Rust
    │ │ │ │

    Struct alloc::collections::btree_map::Values

    1.0.0 · source · 
    pub struct Values<'a, K, V> { /* private fields */ }
    Expand description

    An iterator over the values of a BTreeMap.

    │ │ │ │

    This struct is created by the values method on BTreeMap. See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K, V> Clone for Values<'_, K, V>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<K, V: Debug> Debug for Values<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V> Default for Values<'_, K, V>

    source§

    fn default() -> Self

    Creates an empty btree_map::Values.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<K, V> Clone for Values<'_, K, V>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<K, V: Debug> Debug for Values<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<K, V> Default for Values<'_, K, V>

    source§

    fn default() -> Self

    Creates an empty btree_map::Values.

    │ │ │ │ │ │ │ │ 
    let iter: btree_map::Values<'_, u8, u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<&'a V>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V> ExactSizeIterator for Values<'_, K, V>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, K, V> Iterator for Values<'a, K, V>

    §

    type Item = &'a V

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a V>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a V>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<&'a V>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V> ExactSizeIterator for Values<'_, K, V>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, K, V> Iterator for Values<'a, K, V>

    §

    type Item = &'a V

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a V>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a V>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for Values<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for Values<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for Values<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for Values<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Sync for Values<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Unpin for Values<'a, K, V>

    §

    impl<'a, K, V> UnwindSafe for Values<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for Values<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for Values<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for Values<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for Values<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Sync for Values<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Unpin for Values<'a, K, V>

    §

    impl<'a, K, V> UnwindSafe for Values<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_map/struct.ValuesMut.html │ │ │ │ @@ -1,216 +1,216 @@ │ │ │ │ ValuesMut in alloc::collections::btree_map - Rust
    │ │ │ │

    Struct alloc::collections::btree_map::ValuesMut

    1.10.0 · source · 
    pub struct ValuesMut<'a, K, V> { /* private fields */ }
    Expand description

    A mutable iterator over the values of a BTreeMap.

    │ │ │ │

    This struct is created by the values_mut method on BTreeMap. See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<K, V: Debug> Debug for ValuesMut<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<&'a mut V>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, K, V> Iterator for ValuesMut<'a, K, V>

    §

    type Item = &'a mut V

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut V>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a mut V>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    source§

    impl<K, V: Debug> Debug for ValuesMut<'_, K, V>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V>

    source§

    fn next_back(&mut self) -> Option<&'a mut V>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, K, V> Iterator for ValuesMut<'a, K, V>

    §

    type Item = &'a mut V

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut V>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a mut V>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for ValuesMut<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for ValuesMut<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for ValuesMut<'a, K, V>
    where │ │ │ │ - K: RefUnwindSafe, │ │ │ │ - V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for ValuesMut<'a, K, V>
    where │ │ │ │ - K: Send, │ │ │ │ - V: Send,

    §

    impl<'a, K, V> Sync for ValuesMut<'a, K, V>
    where │ │ │ │ - K: Sync, │ │ │ │ - V: Sync,

    §

    impl<'a, K, V> Unpin for ValuesMut<'a, K, V>

    §

    impl<'a, K, V> !UnwindSafe for ValuesMut<'a, K, V>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<K, V> FusedIterator for ValuesMut<'_, K, V>

    Auto Trait Implementations§

    §

    impl<'a, K, V> Freeze for ValuesMut<'a, K, V>

    §

    impl<'a, K, V> RefUnwindSafe for ValuesMut<'a, K, V>
    where │ │ │ │ + K: RefUnwindSafe, │ │ │ │ + V: RefUnwindSafe,

    §

    impl<'a, K, V> Send for ValuesMut<'a, K, V>
    where │ │ │ │ + K: Send, │ │ │ │ + V: Send,

    §

    impl<'a, K, V> Sync for ValuesMut<'a, K, V>
    where │ │ │ │ + K: Sync, │ │ │ │ + V: Sync,

    §

    impl<'a, K, V> Unpin for ValuesMut<'a, K, V>

    §

    impl<'a, K, V> !UnwindSafe for ValuesMut<'a, K, V>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.BTreeSet.html │ │ │ │ @@ -1,14 +1,14 @@ │ │ │ │ BTreeSet in alloc::collections::btree_set - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_set::BTreeSet

    1.0.0 · source · 
    pub struct BTreeSet<T, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An ordered set based on a B-Tree.

    │ │ │ │ +

    Struct alloc::collections::btree_set::BTreeSet

    1.0.0 · source · 
    pub struct BTreeSet<T, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An ordered set based on a B-Tree.

    │ │ │ │

    See BTreeMap’s documentation for a detailed discussion of this collection’s performance │ │ │ │ benefits and drawbacks.

    │ │ │ │

    It is a logic error for an item to be modified in such a way that the item’s ordering relative │ │ │ │ -to any other item, as determined by the Ord trait, changes while it is in the set. This is │ │ │ │ -normally only possible through Cell, RefCell, global state, I/O, or unsafe code. │ │ │ │ +to any other item, as determined by the Ord trait, changes while it is in the set. This is │ │ │ │ +normally only possible through Cell, RefCell, global state, I/O, or unsafe code. │ │ │ │ The behavior resulting from such a logic error is not specified, but will be encapsulated to the │ │ │ │ BTreeSet that observed the logic error and not result in undefined behavior. This could │ │ │ │ include panics, incorrect results, aborts, memory leaks, and non-termination.

    │ │ │ │

    Iterators returned by BTreeSet::iter produce their items in order, and take worst-case │ │ │ │ logarithmic and amortized constant time per item returned.

    │ │ │ │

    §Examples

    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │ @@ -43,24 +43,24 @@
│ │ │ │  let set = BTreeSet::from([1, 2, 3]);
    Run
    │ │ │ │

    Implementations§

    source§

    impl<T> BTreeSet<T>

    const: 1.66.0 · source

    pub const fn new() -> BTreeSet<T>

    Makes a new, empty BTreeSet.

    │ │ │ │

    Does not allocate anything on its own.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut set: BTreeSet<i32> = BTreeSet::new();
    Run
    │ │ │ │ -
    source§

    impl<T, A: Allocator + Clone> BTreeSet<T, A>

    source

    pub const fn new_in(alloc: A) -> BTreeSet<T, A>

    🔬This is a nightly-only experimental API. (btreemap_alloc #32838)

    Makes a new BTreeSet with a reasonable choice of B.

    │ │ │ │ +
    source§

    impl<T, A: Allocator + Clone> BTreeSet<T, A>

    source

    pub const fn new_in(alloc: A) -> BTreeSet<T, A>

    🔬This is a nightly-only experimental API. (btreemap_alloc #32838)

    Makes a new BTreeSet with a reasonable choice of B.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  use std::alloc::Global;
│ │ │ │  
│ │ │ │  let mut set: BTreeSet<i32> = BTreeSet::new_in(Global);
    Run
    │ │ │ │
    1.17.0 · source

    pub fn range<K, R>(&self, range: R) -> Range<'_, T> ⓘ
    where │ │ │ │ - K: Ord + ?Sized, │ │ │ │ - T: Borrow<K> + Ord, │ │ │ │ - R: RangeBounds<K>,

    Constructs a double-ended iterator over a sub-range of elements in the set. │ │ │ │ + K: Ord + ?Sized, │ │ │ │ + T: Borrow<K> + Ord, │ │ │ │ + R: RangeBounds<K>,

    Constructs a double-ended iterator over a sub-range of elements in the set. │ │ │ │ The simplest way is to use the range syntax min..max, thus range(min..max) will │ │ │ │ yield elements from min (inclusive) to max (exclusive). │ │ │ │ The range may also be entered as (Bound<T>, Bound<T>), so for example │ │ │ │ range((Excluded(4), Included(10))) will yield a left-exclusive, right-inclusive │ │ │ │ range from 4 to 10.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if range start > end. │ │ │ │ @@ -77,15 +77,15 @@ │ │ │ │ println!("{elem}"); │ │ │ │ } │ │ │ │ assert_eq!(Some(&5), set.range(4..).next());Run

    │ │ │ │
    source

    pub fn difference<'a>( │ │ │ │ &'a self, │ │ │ │ other: &'a BTreeSet<T, A> │ │ │ │ ) -> Difference<'a, T, A> ⓘ
    where │ │ │ │ - T: Ord,

    Visits the elements representing the difference, │ │ │ │ + T: Ord,

    Visits the elements representing the difference, │ │ │ │ i.e., the elements that are in self but not in other, │ │ │ │ in ascending order.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut a = BTreeSet::new();
│ │ │ │  a.insert(1);
│ │ │ │ @@ -97,15 +97,15 @@
│ │ │ │  
│ │ │ │  let diff: Vec<_> = a.difference(&b).cloned().collect();
│ │ │ │  assert_eq!(diff, [1]);
    Run
    │ │ │ │
    source

    pub fn symmetric_difference<'a>( │ │ │ │ &'a self, │ │ │ │ other: &'a BTreeSet<T, A> │ │ │ │ ) -> SymmetricDifference<'a, T> ⓘ
    where │ │ │ │ - T: Ord,

    Visits the elements representing the symmetric difference, │ │ │ │ + T: Ord,

    Visits the elements representing the symmetric difference, │ │ │ │ i.e., the elements that are in self or in other but not in both, │ │ │ │ in ascending order.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut a = BTreeSet::new();
│ │ │ │  a.insert(1);
│ │ │ │ @@ -117,15 +117,15 @@
│ │ │ │  
│ │ │ │  let sym_diff: Vec<_> = a.symmetric_difference(&b).cloned().collect();
│ │ │ │  assert_eq!(sym_diff, [1, 3]);
    Run
    │ │ │ │
    source

    pub fn intersection<'a>( │ │ │ │ &'a self, │ │ │ │ other: &'a BTreeSet<T, A> │ │ │ │ ) -> Intersection<'a, T, A> ⓘ
    where │ │ │ │ - T: Ord,

    Visits the elements representing the intersection, │ │ │ │ + T: Ord,

    Visits the elements representing the intersection, │ │ │ │ i.e., the elements that are both in self and other, │ │ │ │ in ascending order.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut a = BTreeSet::new();
│ │ │ │  a.insert(1);
│ │ │ │ @@ -134,92 +134,92 @@
│ │ │ │  let mut b = BTreeSet::new();
│ │ │ │  b.insert(2);
│ │ │ │  b.insert(3);
│ │ │ │  
│ │ │ │  let intersection: Vec<_> = a.intersection(&b).cloned().collect();
│ │ │ │  assert_eq!(intersection, [2]);
    Run
    │ │ │ │
    source

    pub fn union<'a>(&'a self, other: &'a BTreeSet<T, A>) -> Union<'a, T> ⓘ
    where │ │ │ │ - T: Ord,

    Visits the elements representing the union, │ │ │ │ + T: Ord,

    Visits the elements representing the union, │ │ │ │ i.e., all the elements in self or other, without duplicates, │ │ │ │ in ascending order.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut a = BTreeSet::new();
│ │ │ │  a.insert(1);
│ │ │ │  
│ │ │ │  let mut b = BTreeSet::new();
│ │ │ │  b.insert(2);
│ │ │ │  
│ │ │ │  let union: Vec<_> = a.union(&b).cloned().collect();
│ │ │ │  assert_eq!(union, [1, 2]);
    Run
    │ │ │ │
    source

    pub fn clear(&mut self)
    where │ │ │ │ - A: Clone,

    Clears the set, removing all elements.

    │ │ │ │ + A: Clone,

    Clears the set, removing all elements.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut v = BTreeSet::new();
│ │ │ │  v.insert(1);
│ │ │ │  v.clear();
│ │ │ │  assert!(v.is_empty());
    Run
    │ │ │ │ -
    source

    pub fn contains<Q>(&self, value: &Q) -> bool
    where │ │ │ │ - T: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    Returns true if the set contains an element equal to the value.

    │ │ │ │ +
    source

    pub fn contains<Q>(&self, value: &Q) -> bool
    where │ │ │ │ + T: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    Returns true if the set contains an element equal to the value.

    │ │ │ │

    The value may be any borrowed form of the set’s element type, │ │ │ │ but the ordering on the borrowed form must match the │ │ │ │ ordering on the element type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let set = BTreeSet::from([1, 2, 3]);
│ │ │ │  assert_eq!(set.contains(&1), true);
│ │ │ │  assert_eq!(set.contains(&4), false);
    Run
    │ │ │ │ -
    1.9.0 · source

    pub fn get<Q>(&self, value: &Q) -> Option<&T>
    where │ │ │ │ - T: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    Returns a reference to the element in the set, if any, that is equal to │ │ │ │ +

    1.9.0 · source

    pub fn get<Q>(&self, value: &Q) -> Option<&T>
    where │ │ │ │ + T: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    Returns a reference to the element in the set, if any, that is equal to │ │ │ │ the value.

    │ │ │ │

    The value may be any borrowed form of the set’s element type, │ │ │ │ but the ordering on the borrowed form must match the │ │ │ │ ordering on the element type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let set = BTreeSet::from([1, 2, 3]);
│ │ │ │  assert_eq!(set.get(&2), Some(&2));
│ │ │ │  assert_eq!(set.get(&4), None);
    Run
    │ │ │ │ -
    source

    pub fn is_disjoint(&self, other: &BTreeSet<T, A>) -> bool
    where │ │ │ │ - T: Ord,

    Returns true if self has no elements in common with other. │ │ │ │ +

    source

    pub fn is_disjoint(&self, other: &BTreeSet<T, A>) -> bool
    where │ │ │ │ + T: Ord,

    Returns true if self has no elements in common with other. │ │ │ │ This is equivalent to checking for an empty intersection.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let a = BTreeSet::from([1, 2, 3]);
│ │ │ │  let mut b = BTreeSet::new();
│ │ │ │  
│ │ │ │  assert_eq!(a.is_disjoint(&b), true);
│ │ │ │  b.insert(4);
│ │ │ │  assert_eq!(a.is_disjoint(&b), true);
│ │ │ │  b.insert(1);
│ │ │ │  assert_eq!(a.is_disjoint(&b), false);
    Run
    │ │ │ │ -
    source

    pub fn is_subset(&self, other: &BTreeSet<T, A>) -> bool
    where │ │ │ │ - T: Ord,

    Returns true if the set is a subset of another, │ │ │ │ +

    source

    pub fn is_subset(&self, other: &BTreeSet<T, A>) -> bool
    where │ │ │ │ + T: Ord,

    Returns true if the set is a subset of another, │ │ │ │ i.e., other contains at least all the elements in self.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let sup = BTreeSet::from([1, 2, 3]);
│ │ │ │  let mut set = BTreeSet::new();
│ │ │ │  
│ │ │ │  assert_eq!(set.is_subset(&sup), true);
│ │ │ │  set.insert(2);
│ │ │ │  assert_eq!(set.is_subset(&sup), true);
│ │ │ │  set.insert(4);
│ │ │ │  assert_eq!(set.is_subset(&sup), false);
    Run
    │ │ │ │ -
    source

    pub fn is_superset(&self, other: &BTreeSet<T, A>) -> bool
    where │ │ │ │ - T: Ord,

    Returns true if the set is a superset of another, │ │ │ │ +

    source

    pub fn is_superset(&self, other: &BTreeSet<T, A>) -> bool
    where │ │ │ │ + T: Ord,

    Returns true if the set is a superset of another, │ │ │ │ i.e., self contains at least all the elements in other.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let sub = BTreeSet::from([1, 2]);
│ │ │ │  let mut set = BTreeSet::new();
│ │ │ │  
│ │ │ │ @@ -227,70 +227,70 @@
│ │ │ │  
│ │ │ │  set.insert(0);
│ │ │ │  set.insert(1);
│ │ │ │  assert_eq!(set.is_superset(&sub), false);
│ │ │ │  
│ │ │ │  set.insert(2);
│ │ │ │  assert_eq!(set.is_superset(&sub), true);
    Run
    │ │ │ │ -
    1.66.0 · source

    pub fn first(&self) -> Option<&T>
    where │ │ │ │ - T: Ord,

    Returns a reference to the first element in the set, if any. │ │ │ │ +

    1.66.0 · source

    pub fn first(&self) -> Option<&T>
    where │ │ │ │ + T: Ord,

    Returns a reference to the first element in the set, if any. │ │ │ │ This element is always the minimum of all elements in the set.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut set = BTreeSet::new();
│ │ │ │  assert_eq!(set.first(), None);
│ │ │ │  set.insert(1);
│ │ │ │  assert_eq!(set.first(), Some(&1));
│ │ │ │  set.insert(2);
│ │ │ │  assert_eq!(set.first(), Some(&1));
    Run
    │ │ │ │ -
    1.66.0 · source

    pub fn last(&self) -> Option<&T>
    where │ │ │ │ - T: Ord,

    Returns a reference to the last element in the set, if any. │ │ │ │ +

    1.66.0 · source

    pub fn last(&self) -> Option<&T>
    where │ │ │ │ + T: Ord,

    Returns a reference to the last element in the set, if any. │ │ │ │ This element is always the maximum of all elements in the set.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut set = BTreeSet::new();
│ │ │ │  assert_eq!(set.last(), None);
│ │ │ │  set.insert(1);
│ │ │ │  assert_eq!(set.last(), Some(&1));
│ │ │ │  set.insert(2);
│ │ │ │  assert_eq!(set.last(), Some(&2));
    Run
    │ │ │ │ -
    1.66.0 · source

    pub fn pop_first(&mut self) -> Option<T>
    where │ │ │ │ - T: Ord,

    Removes the first element from the set and returns it, if any. │ │ │ │ +

    1.66.0 · source

    pub fn pop_first(&mut self) -> Option<T>
    where │ │ │ │ + T: Ord,

    Removes the first element from the set and returns it, if any. │ │ │ │ The first element is always the minimum element in the set.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut set = BTreeSet::new();
│ │ │ │  
│ │ │ │  set.insert(1);
│ │ │ │  while let Some(n) = set.pop_first() {
│ │ │ │      assert_eq!(n, 1);
│ │ │ │  }
│ │ │ │  assert!(set.is_empty());
    Run
    │ │ │ │ -
    1.66.0 · source

    pub fn pop_last(&mut self) -> Option<T>
    where │ │ │ │ - T: Ord,

    Removes the last element from the set and returns it, if any. │ │ │ │ +

    1.66.0 · source

    pub fn pop_last(&mut self) -> Option<T>
    where │ │ │ │ + T: Ord,

    Removes the last element from the set and returns it, if any. │ │ │ │ The last element is always the maximum element in the set.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut set = BTreeSet::new();
│ │ │ │  
│ │ │ │  set.insert(1);
│ │ │ │  while let Some(n) = set.pop_last() {
│ │ │ │      assert_eq!(n, 1);
│ │ │ │  }
│ │ │ │  assert!(set.is_empty());
    Run
    │ │ │ │ -
    source

    pub fn insert(&mut self, value: T) -> bool
    where │ │ │ │ - T: Ord,

    Adds a value to the set.

    │ │ │ │ +
    source

    pub fn insert(&mut self, value: T) -> bool
    where │ │ │ │ + T: Ord,

    Adds a value to the set.

    │ │ │ │

    Returns whether the value was newly inserted. That is:

    │ │ │ │
      │ │ │ │
    • If the set did not previously contain an equal value, true is │ │ │ │ returned.
      • │ │ │ │
    • If the set already contained an equal value, false is returned, and │ │ │ │ the entry is not updated.
      • │ │ │ │
    │ │ │ │ @@ -299,69 +299,69 @@ │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut set = BTreeSet::new();
│ │ │ │  
│ │ │ │  assert_eq!(set.insert(2), true);
│ │ │ │  assert_eq!(set.insert(2), false);
│ │ │ │  assert_eq!(set.len(), 1);
    Run
    │ │ │ │ -
    1.9.0 · source

    pub fn replace(&mut self, value: T) -> Option<T>
    where │ │ │ │ - T: Ord,

    Adds a value to the set, replacing the existing element, if any, that is │ │ │ │ +

    1.9.0 · source

    pub fn replace(&mut self, value: T) -> Option<T>
    where │ │ │ │ + T: Ord,

    Adds a value to the set, replacing the existing element, if any, that is │ │ │ │ equal to the value. Returns the replaced element.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut set = BTreeSet::new();
│ │ │ │  set.insert(Vec::<i32>::new());
│ │ │ │  
│ │ │ │  assert_eq!(set.get(&[][..]).unwrap().capacity(), 0);
│ │ │ │  set.replace(Vec::with_capacity(10));
│ │ │ │  assert_eq!(set.get(&[][..]).unwrap().capacity(), 10);
    Run
    │ │ │ │ -
    source

    pub fn remove<Q>(&mut self, value: &Q) -> bool
    where │ │ │ │ - T: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    If the set contains an element equal to the value, removes it from the │ │ │ │ +

    source

    pub fn remove<Q>(&mut self, value: &Q) -> bool
    where │ │ │ │ + T: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    If the set contains an element equal to the value, removes it from the │ │ │ │ set and drops it. Returns whether such an element was present.

    │ │ │ │

    The value may be any borrowed form of the set’s element type, │ │ │ │ but the ordering on the borrowed form must match the │ │ │ │ ordering on the element type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut set = BTreeSet::new();
│ │ │ │  
│ │ │ │  set.insert(2);
│ │ │ │  assert_eq!(set.remove(&2), true);
│ │ │ │  assert_eq!(set.remove(&2), false);
    Run
    │ │ │ │ -
    1.9.0 · source

    pub fn take<Q>(&mut self, value: &Q) -> Option<T>
    where │ │ │ │ - T: Borrow<Q> + Ord, │ │ │ │ - Q: Ord + ?Sized,

    Removes and returns the element in the set, if any, that is equal to │ │ │ │ +

    1.9.0 · source

    pub fn take<Q>(&mut self, value: &Q) -> Option<T>
    where │ │ │ │ + T: Borrow<Q> + Ord, │ │ │ │ + Q: Ord + ?Sized,

    Removes and returns the element in the set, if any, that is equal to │ │ │ │ the value.

    │ │ │ │

    The value may be any borrowed form of the set’s element type, │ │ │ │ but the ordering on the borrowed form must match the │ │ │ │ ordering on the element type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut set = BTreeSet::from([1, 2, 3]);
│ │ │ │  assert_eq!(set.take(&2), Some(2));
│ │ │ │  assert_eq!(set.take(&2), None);
    Run
    │ │ │ │
    1.53.0 · source

    pub fn retain<F>(&mut self, f: F)
    where │ │ │ │ - T: Ord, │ │ │ │ - F: FnMut(&T) -> bool,

    Retains only the elements specified by the predicate.

    │ │ │ │ + T: Ord, │ │ │ │ + F: FnMut(&T) -> bool,

    Retains only the elements specified by the predicate.

    │ │ │ │

    In other words, remove all elements e for which f(&e) returns false. │ │ │ │ The elements are visited in ascending order.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
│ │ │ │  // Keep only the even numbers.
│ │ │ │  set.retain(|&k| k % 2 == 0);
│ │ │ │  assert!(set.iter().eq([2, 4, 6].iter()));
    Run
    │ │ │ │ -
    1.11.0 · source

    pub fn append(&mut self, other: &mut Self)
    where │ │ │ │ - T: Ord, │ │ │ │ - A: Clone,

    Moves all elements from other into self, leaving other empty.

    │ │ │ │ +
    1.11.0 · source

    pub fn append(&mut self, other: &mut Self)
    where │ │ │ │ + T: Ord, │ │ │ │ + A: Clone,

    Moves all elements from other into self, leaving other empty.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut a = BTreeSet::new();
│ │ │ │  a.insert(1);
│ │ │ │  a.insert(2);
│ │ │ │  a.insert(3);
│ │ │ │ @@ -377,17 +377,17 @@
│ │ │ │  assert_eq!(b.len(), 0);
│ │ │ │  
│ │ │ │  assert!(a.contains(&1));
│ │ │ │  assert!(a.contains(&2));
│ │ │ │  assert!(a.contains(&3));
│ │ │ │  assert!(a.contains(&4));
│ │ │ │  assert!(a.contains(&5));
    Run
    │ │ │ │ -
    1.11.0 · source

    pub fn split_off<Q: ?Sized + Ord>(&mut self, value: &Q) -> Self
    where │ │ │ │ - T: Borrow<Q> + Ord, │ │ │ │ - A: Clone,

    Splits the collection into two at the value. Returns a new collection │ │ │ │ +

    1.11.0 · source

    pub fn split_off<Q: ?Sized + Ord>(&mut self, value: &Q) -> Self
    where │ │ │ │ + T: Borrow<Q> + Ord, │ │ │ │ + A: Clone,

    Splits the collection into two at the value. Returns a new collection │ │ │ │ with all elements greater than or equal to the value.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut a = BTreeSet::new();
│ │ │ │ @@ -405,16 +405,16 @@
│ │ │ │  assert!(a.contains(&1));
│ │ │ │  assert!(a.contains(&2));
│ │ │ │  
│ │ │ │  assert!(b.contains(&3));
│ │ │ │  assert!(b.contains(&17));
│ │ │ │  assert!(b.contains(&41));
    Run
    │ │ │ │
    source

    pub fn extract_if<'a, F>(&'a mut self, pred: F) -> ExtractIf<'a, T, F, A> ⓘ
    where │ │ │ │ - T: Ord, │ │ │ │ - F: 'a + FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (btree_extract_if #70530)

    Creates an iterator that visits all elements in ascending order and │ │ │ │ + T: Ord, │ │ │ │ + F: 'a + FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (btree_extract_if #70530)

    Creates an iterator that visits all elements in ascending order and │ │ │ │ uses a closure to determine if an element should be removed.

    │ │ │ │

    If the closure returns true, the element is removed from the set and │ │ │ │ yielded. If the closure returns false, or panics, the element remains │ │ │ │ in the set and will not be yielded.

    │ │ │ │

    If the returned ExtractIf is not exhausted, e.g. because it is dropped without iterating │ │ │ │ or the iteration short-circuits, then the remaining elements will be retained. │ │ │ │ Use retain with a negated predicate if you do not need the returned iterator.

    │ │ │ │ @@ -436,106 +436,106 @@ │ │ │ │ │ │ │ │ let set = BTreeSet::from([3, 1, 2]); │ │ │ │ let mut set_iter = set.iter(); │ │ │ │ assert_eq!(set_iter.next(), Some(&1)); │ │ │ │ assert_eq!(set_iter.next(), Some(&2)); │ │ │ │ assert_eq!(set_iter.next(), Some(&3)); │ │ │ │ assert_eq!(set_iter.next(), None);    Run
    │ │ │ │ -
    const: unstable · source

    pub fn len(&self) -> usize

    Returns the number of elements in the set.

    │ │ │ │ +
    const: unstable · source

    pub fn len(&self) -> usize

    Returns the number of elements in the set.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut v = BTreeSet::new();
│ │ │ │  assert_eq!(v.len(), 0);
│ │ │ │  v.insert(1);
│ │ │ │  assert_eq!(v.len(), 1);
    Run
    │ │ │ │ -
    const: unstable · source

    pub fn is_empty(&self) -> bool

    Returns true if the set contains no elements.

    │ │ │ │ +
    const: unstable · source

    pub fn is_empty(&self) -> bool

    Returns true if the set contains no elements.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let mut v = BTreeSet::new();
│ │ │ │  assert!(v.is_empty());
│ │ │ │  v.insert(1);
│ │ │ │  assert!(!v.is_empty());
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: Ord + Clone, A: Allocator + Clone> BitAnd<&BTreeSet<T, A>> for &BTreeSet<T, A>

    source§

    fn bitand(self, rhs: &BTreeSet<T, A>) -> BTreeSet<T, A>

    Returns the intersection of self and rhs as a new BTreeSet<T>.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: Ord + Clone, A: Allocator + Clone> BitAnd<&BTreeSet<T, A>> for &BTreeSet<T, A>

    source§

    fn bitand(self, rhs: &BTreeSet<T, A>) -> BTreeSet<T, A>

    Returns the intersection of self and rhs as a new BTreeSet<T>.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let a = BTreeSet::from([1, 2, 3]);
│ │ │ │  let b = BTreeSet::from([2, 3, 4]);
│ │ │ │  
│ │ │ │  let result = &a & &b;
│ │ │ │  assert_eq!(result, BTreeSet::from([2, 3]));
    Run
    │ │ │ │ -
    §

    type Output = BTreeSet<T, A>

    The resulting type after applying the & operator.
    source§

    impl<T: Ord + Clone, A: Allocator + Clone> BitOr<&BTreeSet<T, A>> for &BTreeSet<T, A>

    source§

    fn bitor(self, rhs: &BTreeSet<T, A>) -> BTreeSet<T, A>

    Returns the union of self and rhs as a new BTreeSet<T>.

    │ │ │ │ +
    §

    type Output = BTreeSet<T, A>

    The resulting type after applying the & operator.
    source§

    impl<T: Ord + Clone, A: Allocator + Clone> BitOr<&BTreeSet<T, A>> for &BTreeSet<T, A>

    source§

    fn bitor(self, rhs: &BTreeSet<T, A>) -> BTreeSet<T, A>

    Returns the union of self and rhs as a new BTreeSet<T>.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let a = BTreeSet::from([1, 2, 3]);
│ │ │ │  let b = BTreeSet::from([3, 4, 5]);
│ │ │ │  
│ │ │ │  let result = &a | &b;
│ │ │ │  assert_eq!(result, BTreeSet::from([1, 2, 3, 4, 5]));
    Run
    │ │ │ │ -
    §

    type Output = BTreeSet<T, A>

    The resulting type after applying the | operator.
    source§

    impl<T: Ord + Clone, A: Allocator + Clone> BitXor<&BTreeSet<T, A>> for &BTreeSet<T, A>

    source§

    fn bitxor(self, rhs: &BTreeSet<T, A>) -> BTreeSet<T, A>

    Returns the symmetric difference of self and rhs as a new BTreeSet<T>.

    │ │ │ │ +
    §

    type Output = BTreeSet<T, A>

    The resulting type after applying the | operator.
    source§

    impl<T: Ord + Clone, A: Allocator + Clone> BitXor<&BTreeSet<T, A>> for &BTreeSet<T, A>

    source§

    fn bitxor(self, rhs: &BTreeSet<T, A>) -> BTreeSet<T, A>

    Returns the symmetric difference of self and rhs as a new BTreeSet<T>.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let a = BTreeSet::from([1, 2, 3]);
│ │ │ │  let b = BTreeSet::from([2, 3, 4]);
│ │ │ │  
│ │ │ │  let result = &a ^ &b;
│ │ │ │  assert_eq!(result, BTreeSet::from([1, 4]));
    Run
    │ │ │ │ -
    §

    type Output = BTreeSet<T, A>

    The resulting type after applying the ^ operator.
    source§

    impl<T: Clone, A: Allocator + Clone> Clone for BTreeSet<T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, other: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Debug, A: Allocator + Clone> Debug for BTreeSet<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T> Default for BTreeSet<T>

    source§

    fn default() -> BTreeSet<T>

    Creates an empty BTreeSet.

    │ │ │ │ -
    1.2.0 · source§

    impl<'a, T: 'a + Ord + Copy, A: Allocator + Clone> Extend<&'a T> for BTreeSet<T, A>

    source§

    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: &'a T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl<T: Ord, A: Allocator + Clone> Extend<T> for BTreeSet<T, A>

    source§

    fn extend<Iter: IntoIterator<Item = T>>(&mut self, iter: Iter)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.56.0 · source§

    impl<T: Ord, const N: usize> From<[T; N]> for BTreeSet<T>

    source§

    fn from(arr: [T; N]) -> Self

    Converts a [T; N] into a BTreeSet<T>.

    │ │ │ │ +
    §

    type Output = BTreeSet<T, A>

    The resulting type after applying the ^ operator.
    source§

    impl<T: Clone, A: Allocator + Clone> Clone for BTreeSet<T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, other: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Debug, A: Allocator + Clone> Debug for BTreeSet<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T> Default for BTreeSet<T>

    source§

    fn default() -> BTreeSet<T>

    Creates an empty BTreeSet.

    │ │ │ │ +
    1.2.0 · source§

    impl<'a, T: 'a + Ord + Copy, A: Allocator + Clone> Extend<&'a T> for BTreeSet<T, A>

    source§

    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: &'a T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl<T: Ord, A: Allocator + Clone> Extend<T> for BTreeSet<T, A>

    source§

    fn extend<Iter: IntoIterator<Item = T>>(&mut self, iter: Iter)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.56.0 · source§

    impl<T: Ord, const N: usize> From<[T; N]> for BTreeSet<T>

    source§

    fn from(arr: [T; N]) -> Self

    Converts a [T; N] into a BTreeSet<T>.

    │ │ │ │ │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let set1 = BTreeSet::from([1, 2, 3, 4]);
│ │ │ │  let set2: BTreeSet<_> = [1, 2, 3, 4].into();
│ │ │ │  assert_eq!(set1, set2);
    Run
    │ │ │ │ -
    source§

    impl<T: Ord> FromIterator<T> for BTreeSet<T>

    source§

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> BTreeSet<T>

    Creates a value from an iterator. Read more
    source§

    impl<T: Hash, A: Allocator + Clone> Hash for BTreeSet<T, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ - H: Hasher, │ │ │ │ - Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<'a, T, A: Allocator + Clone> IntoIterator for &'a BTreeSet<T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    §

    type IntoIter = Iter<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Iter<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<T, A: Allocator + Clone> IntoIterator for BTreeSet<T, A>

    source§

    fn into_iter(self) -> IntoIter<T, A> ⓘ

    Gets an iterator for moving out the BTreeSet’s contents.

    │ │ │ │ +
    source§

    impl<T: Ord> FromIterator<T> for BTreeSet<T>

    source§

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> BTreeSet<T>

    Creates a value from an iterator. Read more
    source§

    impl<T: Hash, A: Allocator + Clone> Hash for BTreeSet<T, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ + H: Hasher, │ │ │ │ + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<'a, T, A: Allocator + Clone> IntoIterator for &'a BTreeSet<T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    §

    type IntoIter = Iter<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Iter<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<T, A: Allocator + Clone> IntoIterator for BTreeSet<T, A>

    source§

    fn into_iter(self) -> IntoIter<T, A> ⓘ

    Gets an iterator for moving out the BTreeSet’s contents.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let set = BTreeSet::from([1, 2, 3, 4]);
│ │ │ │  
│ │ │ │  let v: Vec<_> = set.into_iter().collect();
│ │ │ │  assert_eq!(v, [1, 2, 3, 4]);
    Run
    │ │ │ │ -
    §

    type Item = T

    The type of the elements being iterated over.
    §

    type IntoIter = IntoIter<T, A>

    Which kind of iterator are we turning this into?
    source§

    impl<T: Ord, A: Allocator + Clone> Ord for BTreeSet<T, A>

    source§

    fn cmp(&self, other: &BTreeSet<T, A>) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ - Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<T: PartialEq, A: Allocator + Clone> PartialEq for BTreeSet<T, A>

    source§

    fn eq(&self, other: &BTreeSet<T, A>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<T: PartialOrd, A: Allocator + Clone> PartialOrd for BTreeSet<T, A>

    source§

    fn partial_cmp(&self, other: &BTreeSet<T, A>) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ -operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ -operator. Read more
    source§

    impl<T: Ord + Clone, A: Allocator + Clone> Sub<&BTreeSet<T, A>> for &BTreeSet<T, A>

    source§

    fn sub(self, rhs: &BTreeSet<T, A>) -> BTreeSet<T, A>

    Returns the difference of self and rhs as a new BTreeSet<T>.

    │ │ │ │ +
    §

    type Item = T

    The type of the elements being iterated over.
    §

    type IntoIter = IntoIter<T, A>

    Which kind of iterator are we turning this into?
    source§

    impl<T: Ord, A: Allocator + Clone> Ord for BTreeSet<T, A>

    source§

    fn cmp(&self, other: &BTreeSet<T, A>) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ + Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<T: PartialEq, A: Allocator + Clone> PartialEq for BTreeSet<T, A>

    source§

    fn eq(&self, other: &BTreeSet<T, A>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<T: PartialOrd, A: Allocator + Clone> PartialOrd for BTreeSet<T, A>

    source§

    fn partial_cmp(&self, other: &BTreeSet<T, A>) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ +operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ +operator. Read more
    source§

    impl<T: Ord + Clone, A: Allocator + Clone> Sub<&BTreeSet<T, A>> for &BTreeSet<T, A>

    source§

    fn sub(self, rhs: &BTreeSet<T, A>) -> BTreeSet<T, A>

    Returns the difference of self and rhs as a new BTreeSet<T>.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::BTreeSet;
│ │ │ │  
│ │ │ │  let a = BTreeSet::from([1, 2, 3]);
│ │ │ │  let b = BTreeSet::from([3, 4, 5]);
│ │ │ │  
│ │ │ │  let result = &a - &b;
│ │ │ │  assert_eq!(result, BTreeSet::from([1, 2]));
    Run
    │ │ │ │ -
    §

    type Output = BTreeSet<T, A>

    The resulting type after applying the - operator.
    source§

    impl<T: Eq, A: Allocator + Clone> Eq for BTreeSet<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for BTreeSet<T, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<T, A> RefUnwindSafe for BTreeSet<T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<T, A> Send for BTreeSet<T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<T, A> Sync for BTreeSet<T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<T, A> Unpin for BTreeSet<T, A>
    where │ │ │ │ - A: Unpin,

    §

    impl<T, A> UnwindSafe for BTreeSet<T, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +
    §

    type Output = BTreeSet<T, A>

    The resulting type after applying the - operator.
    source§

    impl<T: Eq, A: Allocator + Clone> Eq for BTreeSet<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for BTreeSet<T, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<T, A> RefUnwindSafe for BTreeSet<T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<T, A> Send for BTreeSet<T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<T, A> Sync for BTreeSet<T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<T, A> Unpin for BTreeSet<T, A>
    where │ │ │ │ + A: Unpin,

    §

    impl<T, A> UnwindSafe for BTreeSet<T, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Difference.html │ │ │ │ @@ -1,203 +1,203 @@ │ │ │ │ Difference in alloc::collections::btree_set - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_set::Difference

    1.0.0 · source · 
    pub struct Difference<'a, T: 'a, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    A lazy iterator producing elements in the difference of BTreeSets.

    │ │ │ │ +

    Struct alloc::collections::btree_set::Difference

    1.0.0 · source · 
    pub struct Difference<'a, T: 'a, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    A lazy iterator producing elements in the difference of BTreeSets.

    │ │ │ │

    This struct is created by the difference method on BTreeSet. │ │ │ │ See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T, A: Allocator + Clone> Clone for Difference<'_, T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug, A: Allocator + Clone> Debug for Difference<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T: Ord, A: Allocator + Clone> Iterator for Difference<'a, T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn min(self) -> Option<&'a T>

    Returns the minimum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    source§

    impl<T, A: Allocator + Clone> Clone for Difference<'_, T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug, A: Allocator + Clone> Debug for Difference<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T: Ord, A: Allocator + Clone> Iterator for Difference<'a, T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn min(self) -> Option<&'a T>

    Returns the minimum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T: Ord, A: Allocator + Clone> FusedIterator for Difference<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for Difference<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for Difference<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, A> Send for Difference<'a, T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, A> Sync for Difference<'a, T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, A> Unpin for Difference<'a, T, A>

    §

    impl<'a, T, A> UnwindSafe for Difference<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T: Ord, A: Allocator + Clone> FusedIterator for Difference<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for Difference<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for Difference<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, A> Send for Difference<'a, T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, A> Sync for Difference<'a, T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, A> Unpin for Difference<'a, T, A>

    §

    impl<'a, T, A> UnwindSafe for Difference<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.ExtractIf.html │ │ │ │ @@ -1,210 +1,210 @@ │ │ │ │ ExtractIf in alloc::collections::btree_set - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_set::ExtractIf

    source · 
    pub struct ExtractIf<'a, T, F, A: Allocator + Clone = Global>
    where
│ │ │ │ +    
    Struct alloc::collections::btree_set::ExtractIf
    source · 
    pub struct ExtractIf<'a, T, F, A: Allocator + Clone = Global>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    F: 'a + FnMut(&T) -> bool,
    { /* private fields */ }
    🔬This is a nightly-only experimental API. (btree_extract_if #70530)
    Expand description
    An iterator produced by calling extract_if on BTreeSet.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<T, F, A: Allocator + Clone> Debug for ExtractIf<'_, T, F, A>
    where
│ │ │ │ +    F: 'a + FnMut(&T) -> bool,
    { /* private fields */ }
    🔬This is a nightly-only experimental API. (btree_extract_if #70530)
    Expand description

    An iterator produced by calling extract_if on BTreeSet.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T, F, A: Allocator + Clone> Debug for ExtractIf<'_, T, F, A>
    where │ │ │ │ T: Debug, │ │ │ │ - F: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, F, A: Allocator + Clone> Iterator for ExtractIf<'_, T, F, A>
    where │ │ │ │ - F: 'a + FnMut(&T) -> bool,

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + F: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, F, A: Allocator + Clone> Iterator for ExtractIf<'_, T, F, A>
    where │ │ │ │ + F: 'a + FnMut(&T) -> bool,

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T, F, A: Allocator + Clone> FusedIterator for ExtractIf<'_, T, F, A>
    where │ │ │ │ - F: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
    where │ │ │ │ - A: Freeze, │ │ │ │ - F: Freeze,

    §

    impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - F: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, F, A> Send for ExtractIf<'a, T, F, A>
    where │ │ │ │ - A: Send, │ │ │ │ - F: Send, │ │ │ │ - T: Send,

    §

    impl<'a, T, F, A> Sync for ExtractIf<'a, T, F, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - F: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
    where │ │ │ │ - A: Unpin, │ │ │ │ - F: Unpin,

    §

    impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T, F, A: Allocator + Clone> FusedIterator for ExtractIf<'_, T, F, A>
    where │ │ │ │ + F: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
    where │ │ │ │ + A: Freeze, │ │ │ │ + F: Freeze,

    §

    impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + F: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, F, A> Send for ExtractIf<'a, T, F, A>
    where │ │ │ │ + A: Send, │ │ │ │ + F: Send, │ │ │ │ + T: Send,

    §

    impl<'a, T, F, A> Sync for ExtractIf<'a, T, F, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + F: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
    where │ │ │ │ + A: Unpin, │ │ │ │ + F: Unpin,

    §

    impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Intersection.html │ │ │ │ @@ -1,203 +1,203 @@ │ │ │ │ Intersection in alloc::collections::btree_set - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_set::Intersection

    1.0.0 · source · 
    pub struct Intersection<'a, T: 'a, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    A lazy iterator producing elements in the intersection of BTreeSets.

    │ │ │ │ +

    Struct alloc::collections::btree_set::Intersection

    1.0.0 · source · 
    pub struct Intersection<'a, T: 'a, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    A lazy iterator producing elements in the intersection of BTreeSets.

    │ │ │ │

    This struct is created by the intersection method on BTreeSet. │ │ │ │ See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T, A: Allocator + Clone> Clone for Intersection<'_, T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug, A: Allocator + Clone> Debug for Intersection<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T: Ord, A: Allocator + Clone> Iterator for Intersection<'a, T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn min(self) -> Option<&'a T>

    Returns the minimum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    source§

    impl<T, A: Allocator + Clone> Clone for Intersection<'_, T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug, A: Allocator + Clone> Debug for Intersection<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T: Ord, A: Allocator + Clone> Iterator for Intersection<'a, T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn min(self) -> Option<&'a T>

    Returns the minimum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T: Ord, A: Allocator + Clone> FusedIterator for Intersection<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for Intersection<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for Intersection<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, A> Send for Intersection<'a, T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, A> Sync for Intersection<'a, T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, A> Unpin for Intersection<'a, T, A>

    §

    impl<'a, T, A> UnwindSafe for Intersection<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T: Ord, A: Allocator + Clone> FusedIterator for Intersection<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for Intersection<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for Intersection<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, A> Send for Intersection<'a, T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, A> Sync for Intersection<'a, T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, A> Unpin for Intersection<'a, T, A>

    §

    impl<'a, T, A> UnwindSafe for Intersection<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.IntoIter.html │ │ │ │ @@ -1,226 +1,226 @@ │ │ │ │ IntoIter in alloc::collections::btree_set - Rust
    │ │ │ │ -

    Struct alloc::collections::btree_set::IntoIter

    1.0.0 · source · 
    pub struct IntoIter<T, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An owning iterator over the items of a BTreeSet.

    │ │ │ │ +

    Struct alloc::collections::btree_set::IntoIter

    1.0.0 · source · 
    pub struct IntoIter<T, A: Allocator + Clone = Global> { /* private fields */ }
    Expand description

    An owning iterator over the items of a BTreeSet.

    │ │ │ │

    This struct is created by the into_iter method on BTreeSet │ │ │ │ -(provided by the IntoIterator trait). See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: Debug, A: Debug + Allocator + Clone> Debug for IntoIter<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T, A> Default for IntoIter<T, A>
    where │ │ │ │ - A: Allocator + Default + Clone,

    source§

    fn default() -> Self

    Creates an empty btree_set::IntoIter.

    │ │ │ │ +(provided by the IntoIterator trait). See its documentation for more.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: Debug, A: Debug + Allocator + Clone> Debug for IntoIter<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T, A> Default for IntoIter<T, A>
    where │ │ │ │ + A: Allocator + Default + Clone,

    source§

    fn default() -> Self

    Creates an empty btree_set::IntoIter.

    │ │ │ │ │ │ │ │ 
    let iter: btree_set::IntoIter<u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<T, A: Allocator + Clone> DoubleEndedIterator for IntoIter<T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator + Clone> ExactSizeIterator for IntoIter<T, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<T, A: Allocator + Clone> Iterator for IntoIter<T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<T, A: Allocator + Clone> DoubleEndedIterator for IntoIter<T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator + Clone> ExactSizeIterator for IntoIter<T, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<T, A: Allocator + Clone> Iterator for IntoIter<T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T, A: Allocator + Clone> FusedIterator for IntoIter<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for IntoIter<T, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<T, A> RefUnwindSafe for IntoIter<T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<T, A> Send for IntoIter<T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<T, A> Sync for IntoIter<T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<T, A> Unpin for IntoIter<T, A>
    where │ │ │ │ - A: Unpin,

    §

    impl<T, A> UnwindSafe for IntoIter<T, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T, A: Allocator + Clone> FusedIterator for IntoIter<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for IntoIter<T, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<T, A> RefUnwindSafe for IntoIter<T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<T, A> Send for IntoIter<T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<T, A> Sync for IntoIter<T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<T, A> Unpin for IntoIter<T, A>
    where │ │ │ │ + A: Unpin,

    §

    impl<T, A> UnwindSafe for IntoIter<T, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Iter.html │ │ │ │ @@ -1,222 +1,222 @@ │ │ │ │ Iter in alloc::collections::btree_set - Rust
    │ │ │ │

    Struct alloc::collections::btree_set::Iter

    1.0.0 · source · 
    pub struct Iter<'a, T: 'a> { /* private fields */ }
    Expand description

    An iterator over the items of a BTreeSet.

    │ │ │ │

    This struct is created by the iter method on BTreeSet. │ │ │ │ See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T> Clone for Iter<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for Iter<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for Iter<'_, T>

    source§

    fn default() -> Self

    Creates an empty btree_set::Iter.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T> Clone for Iter<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for Iter<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for Iter<'_, T>

    source§

    fn default() -> Self

    Creates an empty btree_set::Iter.

    │ │ │ │ │ │ │ │ 
    let iter: btree_set::Iter<'_, u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<'a, T> DoubleEndedIterator for Iter<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for Iter<'_, T>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, T> Iterator for Iter<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<&'a T>
    where │ │ │ │ - &'a T: Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<&'a T>
    where │ │ │ │ - &'a T: Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<'a, T> DoubleEndedIterator for Iter<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for Iter<'_, T>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, T> Iterator for Iter<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<&'a T>
    where │ │ │ │ + &'a T: Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<&'a T>
    where │ │ │ │ + &'a T: Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Iter<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Iter<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Iter<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for Iter<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Sync for Iter<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for Iter<'a, T>

    §

    impl<'a, T> UnwindSafe for Iter<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Iter<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Iter<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Iter<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for Iter<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Sync for Iter<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for Iter<'a, T>

    §

    impl<'a, T> UnwindSafe for Iter<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Range.html │ │ │ │ @@ -1,219 +1,219 @@ │ │ │ │ Range in alloc::collections::btree_set - Rust
    │ │ │ │

    Struct alloc::collections::btree_set::Range

    1.17.0 · source · 
    pub struct Range<'a, T: 'a> { /* private fields */ }
    Expand description

    An iterator over a sub-range of items in a BTreeSet.

    │ │ │ │

    This struct is created by the range method on BTreeSet. │ │ │ │ See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T> Clone for Range<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a, T: Debug + 'a> Debug for Range<'a, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for Range<'_, T>

    source§

    fn default() -> Self

    Creates an empty btree_set::Range.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T> Clone for Range<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a, T: Debug + 'a> Debug for Range<'a, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for Range<'_, T>

    source§

    fn default() -> Self

    Creates an empty btree_set::Range.

    │ │ │ │ │ │ │ │ 
    let iter: btree_set::Range<'_, u8> = Default::default();
│ │ │ │  assert_eq!(iter.count(), 0);
    Run
    │ │ │ │ -
    source§

    impl<'a, T> DoubleEndedIterator for Range<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T> Iterator for Range<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn last(self) -> Option<&'a T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<&'a T>
    where │ │ │ │ - &'a T: Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<&'a T>
    where │ │ │ │ - &'a T: Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<'a, T> DoubleEndedIterator for Range<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T> Iterator for Range<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn last(self) -> Option<&'a T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn min(self) -> Option<&'a T>
    where │ │ │ │ + &'a T: Ord,

    Returns the minimum element of an iterator. Read more
    source§

    fn max(self) -> Option<&'a T>
    where │ │ │ │ + &'a T: Ord,

    Returns the maximum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Range<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Range<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Range<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for Range<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Sync for Range<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for Range<'a, T>

    §

    impl<'a, T> UnwindSafe for Range<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Range<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Range<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Range<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for Range<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Sync for Range<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for Range<'a, T>

    §

    impl<'a, T> UnwindSafe for Range<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.SymmetricDifference.html │ │ │ │ @@ -1,199 +1,199 @@ │ │ │ │ SymmetricDifference in alloc::collections::btree_set - Rust
    │ │ │ │

    Struct alloc::collections::btree_set::SymmetricDifference

    1.0.0 · source · 
    pub struct SymmetricDifference<'a, T: 'a>(/* private fields */);
    Expand description

    A lazy iterator producing elements in the symmetric difference of BTreeSets.

    │ │ │ │

    This struct is created by the symmetric_difference method on │ │ │ │ BTreeSet. See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T> Clone for SymmetricDifference<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for SymmetricDifference<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn min(self) -> Option<&'a T>

    Returns the minimum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    source§

    impl<T> Clone for SymmetricDifference<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for SymmetricDifference<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn min(self) -> Option<&'a T>

    Returns the minimum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T: Ord> FusedIterator for SymmetricDifference<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for SymmetricDifference<'a, T>

    §

    impl<'a, T> RefUnwindSafe for SymmetricDifference<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for SymmetricDifference<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Sync for SymmetricDifference<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for SymmetricDifference<'a, T>

    §

    impl<'a, T> UnwindSafe for SymmetricDifference<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T: Ord> FusedIterator for SymmetricDifference<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for SymmetricDifference<'a, T>

    §

    impl<'a, T> RefUnwindSafe for SymmetricDifference<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for SymmetricDifference<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Sync for SymmetricDifference<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for SymmetricDifference<'a, T>

    §

    impl<'a, T> UnwindSafe for SymmetricDifference<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/btree_set/struct.Union.html │ │ │ │ @@ -1,199 +1,199 @@ │ │ │ │ Union in alloc::collections::btree_set - Rust
    │ │ │ │

    Struct alloc::collections::btree_set::Union

    1.0.0 · source · 
    pub struct Union<'a, T: 'a>(/* private fields */);
    Expand description

    A lazy iterator producing elements in the union of BTreeSets.

    │ │ │ │

    This struct is created by the union method on BTreeSet. │ │ │ │ See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T> Clone for Union<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for Union<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T: Ord> Iterator for Union<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn min(self) -> Option<&'a T>

    Returns the minimum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    source§

    impl<T> Clone for Union<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for Union<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T: Ord> Iterator for Union<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn min(self) -> Option<&'a T>

    Returns the minimum element of an iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T: Ord> FusedIterator for Union<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Union<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Union<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for Union<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Sync for Union<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for Union<'a, T>

    §

    impl<'a, T> UnwindSafe for Union<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T: Ord> FusedIterator for Union<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Union<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Union<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for Union<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Sync for Union<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for Union<'a, T>

    §

    impl<'a, T> UnwindSafe for Union<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/enum.TryReserveErrorKind.html │ │ │ │ @@ -6,22 +6,22 @@ │ │ │ │ /* private fields */ │ │ │ │ }, │ │ │ │ }
    🔬This is a nightly-only experimental API. (try_reserve_kind #48043)
    Expand description

    Details of the allocation that caused a TryReserveError

    │ │ │ │

    Variants§

    §

    CapacityOverflow

    🔬This is a nightly-only experimental API. (try_reserve_kind #48043)

    Error due to the computed capacity exceeding the collection’s maximum │ │ │ │ (usually isize::MAX bytes).

    │ │ │ │
    §

    AllocError

    Fields

    §layout: Layout
    🔬This is a nightly-only experimental API. (try_reserve_kind #48043)

    The layout of allocation request that failed

    │ │ │ │
    🔬This is a nightly-only experimental API. (try_reserve_kind #48043)

    The memory allocator returned an error

    │ │ │ │ -

    Trait Implementations§

    source§

    impl Clone for TryReserveErrorKind

    source§

    fn clone(&self) -> TryReserveErrorKind

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for TryReserveErrorKind

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl From<LayoutError> for TryReserveErrorKind

    source§

    fn from(_: LayoutError) -> Self

    Always evaluates to TryReserveErrorKind::CapacityOverflow.

    │ │ │ │ -
    source§

    impl From<TryReserveErrorKind> for TryReserveError

    source§

    fn from(kind: TryReserveErrorKind) -> Self

    Converts to this type from the input type.
    source§

    impl PartialEq for TryReserveErrorKind

    source§

    fn eq(&self, other: &TryReserveErrorKind) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for TryReserveErrorKind

    source§

    impl StructuralPartialEq for TryReserveErrorKind

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl Clone for TryReserveErrorKind

    source§

    fn clone(&self) -> TryReserveErrorKind

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for TryReserveErrorKind

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl From<LayoutError> for TryReserveErrorKind

    source§

    fn from(_: LayoutError) -> Self

    Always evaluates to TryReserveErrorKind::CapacityOverflow.

    │ │ │ │ +
    source§

    impl From<TryReserveErrorKind> for TryReserveError

    source§

    fn from(kind: TryReserveErrorKind) -> Self

    Converts to this type from the input type.
    source§

    impl PartialEq for TryReserveErrorKind

    source§

    fn eq(&self, other: &TryReserveErrorKind) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for TryReserveErrorKind

    source§

    impl StructuralPartialEq for TryReserveErrorKind

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.Cursor.html │ │ │ │ @@ -1,50 +1,50 @@ │ │ │ │ Cursor in alloc::collections::linked_list - Rust
    │ │ │ │

    Struct alloc::collections::linked_list::Cursor

    source · 
    pub struct Cursor<'a, T: 'a, A: Allocator = Global> { /* private fields */ }
    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)
    Expand description

    A cursor over a LinkedList.

    │ │ │ │

    A Cursor is like an iterator, except that it can freely seek back-and-forth.

    │ │ │ │

    Cursors always rest between two elements in the list, and index in a logically circular way. │ │ │ │ To accommodate this, there is a “ghost” non-element that yields None between the head and │ │ │ │ tail of the list.

    │ │ │ │

    When created, cursors start at the front of the list, or the “ghost” non-element if the list is empty.

    │ │ │ │ -

    Implementations§

    source§

    impl<'a, T, A: Allocator> Cursor<'a, T, A>

    source

    pub fn index(&self) -> Option<usize>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns the cursor position index within the LinkedList.

    │ │ │ │ +

    Implementations§

    source§

    impl<'a, T, A: Allocator> Cursor<'a, T, A>

    source

    pub fn index(&self) -> Option<usize>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns the cursor position index within the LinkedList.

    │ │ │ │

    This returns None if the cursor is currently pointing to the │ │ │ │ “ghost” non-element.

    │ │ │ │
    source

    pub fn move_next(&mut self)

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Moves the cursor to the next element of the LinkedList.

    │ │ │ │

    If the cursor is pointing to the “ghost” non-element then this will move it to │ │ │ │ the first element of the LinkedList. If it is pointing to the last │ │ │ │ element of the LinkedList then this will move it to the “ghost” non-element.

    │ │ │ │
    source

    pub fn move_prev(&mut self)

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Moves the cursor to the previous element of the LinkedList.

    │ │ │ │

    If the cursor is pointing to the “ghost” non-element then this will move it to │ │ │ │ the last element of the LinkedList. If it is pointing to the first │ │ │ │ element of the LinkedList then this will move it to the “ghost” non-element.

    │ │ │ │ -
    source

    pub fn current(&self) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the element that the cursor is currently │ │ │ │ +

    source

    pub fn current(&self) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the element that the cursor is currently │ │ │ │ pointing to.

    │ │ │ │

    This returns None if the cursor is currently pointing to the │ │ │ │ “ghost” non-element.

    │ │ │ │ -
    source

    pub fn peek_next(&self) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the next element.

    │ │ │ │ +
    source

    pub fn peek_next(&self) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the next element.

    │ │ │ │

    If the cursor is pointing to the “ghost” non-element then this returns │ │ │ │ the first element of the LinkedList. If it is pointing to the last │ │ │ │ element of the LinkedList then this returns None.

    │ │ │ │ -
    source

    pub fn peek_prev(&self) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the previous element.

    │ │ │ │ +
    source

    pub fn peek_prev(&self) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the previous element.

    │ │ │ │

    If the cursor is pointing to the “ghost” non-element then this returns │ │ │ │ the last element of the LinkedList. If it is pointing to the first │ │ │ │ element of the LinkedList then this returns None.

    │ │ │ │ -
    source

    pub fn front(&self) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a reference to the front element of the cursor’s parent list, │ │ │ │ +

    source

    pub fn front(&self) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a reference to the front element of the cursor’s parent list, │ │ │ │ or None if the list is empty.

    │ │ │ │ -
    source

    pub fn back(&self) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a reference to the back element of the cursor’s parent list, │ │ │ │ +

    source

    pub fn back(&self) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a reference to the back element of the cursor’s parent list, │ │ │ │ or None if the list is empty.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T, A: Allocator> Clone for Cursor<'_, T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Debug, A: Allocator> Debug for Cursor<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Sync, A: Allocator + Sync> Send for Cursor<'_, T, A>

    source§

    impl<T: Sync, A: Allocator + Sync> Sync for Cursor<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for Cursor<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for Cursor<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, A> Unpin for Cursor<'a, T, A>

    §

    impl<'a, T, A> UnwindSafe for Cursor<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T, A: Allocator> Clone for Cursor<'_, T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Debug, A: Allocator> Debug for Cursor<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Sync, A: Allocator + Sync> Send for Cursor<'_, T, A>

    source§

    impl<T: Sync, A: Allocator + Sync> Sync for Cursor<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for Cursor<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for Cursor<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, A> Unpin for Cursor<'a, T, A>

    §

    impl<'a, T, A> UnwindSafe for Cursor<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.CursorMut.html │ │ │ │ @@ -3,34 +3,34 @@ │ │ │ │

    A Cursor is like an iterator, except that it can freely seek back-and-forth, and can │ │ │ │ safely mutate the list during iteration. This is because the lifetime of its yielded │ │ │ │ references is tied to its own lifetime, instead of just the underlying list. This means │ │ │ │ cursors cannot yield multiple elements at once.

    │ │ │ │

    Cursors always rest between two elements in the list, and index in a logically circular way. │ │ │ │ To accommodate this, there is a “ghost” non-element that yields None between the head and │ │ │ │ tail of the list.

    │ │ │ │ -

    Implementations§

    source§

    impl<'a, T, A: Allocator> CursorMut<'a, T, A>

    source

    pub fn index(&self) -> Option<usize>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns the cursor position index within the LinkedList.

    │ │ │ │ +

    Implementations§

    source§

    impl<'a, T, A: Allocator> CursorMut<'a, T, A>

    source

    pub fn index(&self) -> Option<usize>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns the cursor position index within the LinkedList.

    │ │ │ │

    This returns None if the cursor is currently pointing to the │ │ │ │ “ghost” non-element.

    │ │ │ │
    source

    pub fn move_next(&mut self)

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Moves the cursor to the next element of the LinkedList.

    │ │ │ │

    If the cursor is pointing to the “ghost” non-element then this will move it to │ │ │ │ the first element of the LinkedList. If it is pointing to the last │ │ │ │ element of the LinkedList then this will move it to the “ghost” non-element.

    │ │ │ │
    source

    pub fn move_prev(&mut self)

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Moves the cursor to the previous element of the LinkedList.

    │ │ │ │

    If the cursor is pointing to the “ghost” non-element then this will move it to │ │ │ │ the last element of the LinkedList. If it is pointing to the first │ │ │ │ element of the LinkedList then this will move it to the “ghost” non-element.

    │ │ │ │ -
    source

    pub fn current(&mut self) -> Option<&mut T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the element that the cursor is currently │ │ │ │ +

    source

    pub fn current(&mut self) -> Option<&mut T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the element that the cursor is currently │ │ │ │ pointing to.

    │ │ │ │

    This returns None if the cursor is currently pointing to the │ │ │ │ “ghost” non-element.

    │ │ │ │ -
    source

    pub fn peek_next(&mut self) -> Option<&mut T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the next element.

    │ │ │ │ +
    source

    pub fn peek_next(&mut self) -> Option<&mut T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the next element.

    │ │ │ │

    If the cursor is pointing to the “ghost” non-element then this returns │ │ │ │ the first element of the LinkedList. If it is pointing to the last │ │ │ │ element of the LinkedList then this returns None.

    │ │ │ │ -
    source

    pub fn peek_prev(&mut self) -> Option<&mut T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the previous element.

    │ │ │ │ +
    source

    pub fn peek_prev(&mut self) -> Option<&mut T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a reference to the previous element.

    │ │ │ │

    If the cursor is pointing to the “ghost” non-element then this returns │ │ │ │ the last element of the LinkedList. If it is pointing to the first │ │ │ │ element of the LinkedList then this returns None.

    │ │ │ │
    source

    pub fn as_cursor(&self) -> Cursor<'_, T, A>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Returns a read-only cursor pointing to the current element.

    │ │ │ │

    The lifetime of the returned Cursor is bound to that of the │ │ │ │ CursorMut, which means it cannot outlive the CursorMut and that the │ │ │ │ CursorMut is frozen for the lifetime of the Cursor.

    │ │ │ │ @@ -42,60 +42,60 @@ │ │ │ │ inserted at the end of the LinkedList.

    │ │ │ │
    source§

    impl<'a, T, A: Allocator> CursorMut<'a, T, A>

    source

    pub fn insert_after(&mut self, item: T)

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Inserts a new element into the LinkedList after the current one.

    │ │ │ │

    If the cursor is pointing at the “ghost” non-element then the new element is │ │ │ │ inserted at the front of the LinkedList.

    │ │ │ │
    source

    pub fn insert_before(&mut self, item: T)

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Inserts a new element into the LinkedList before the current one.

    │ │ │ │

    If the cursor is pointing at the “ghost” non-element then the new element is │ │ │ │ inserted at the end of the LinkedList.

    │ │ │ │ -
    source

    pub fn remove_current(&mut self) -> Option<T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Removes the current element from the LinkedList.

    │ │ │ │ +
    source

    pub fn remove_current(&mut self) -> Option<T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Removes the current element from the LinkedList.

    │ │ │ │

    The element that was removed is returned, and the cursor is │ │ │ │ moved to point to the next element in the LinkedList.

    │ │ │ │

    If the cursor is currently pointing to the “ghost” non-element then no element │ │ │ │ is removed and None is returned.

    │ │ │ │ -
    source

    pub fn remove_current_as_list(&mut self) -> Option<LinkedList<T, A>>
    where │ │ │ │ - A: Clone,

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Removes the current element from the LinkedList without deallocating the list node.

    │ │ │ │ +
    source

    pub fn remove_current_as_list(&mut self) -> Option<LinkedList<T, A>>
    where │ │ │ │ + A: Clone,

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Removes the current element from the LinkedList without deallocating the list node.

    │ │ │ │

    The node that was removed is returned as a new LinkedList containing only this node. │ │ │ │ The cursor is moved to point to the next element in the current LinkedList.

    │ │ │ │

    If the cursor is currently pointing to the “ghost” non-element then no element │ │ │ │ is removed and None is returned.

    │ │ │ │
    source

    pub fn split_after(&mut self) -> LinkedList<T, A>
    where │ │ │ │ - A: Clone,

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Splits the list into two after the current element. This will return a │ │ │ │ + A: Clone,

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Splits the list into two after the current element. This will return a │ │ │ │ new list consisting of everything after the cursor, with the original │ │ │ │ list retaining everything before.

    │ │ │ │

    If the cursor is pointing at the “ghost” non-element then the entire contents │ │ │ │ of the LinkedList are moved.

    │ │ │ │
    source

    pub fn split_before(&mut self) -> LinkedList<T, A>
    where │ │ │ │ - A: Clone,

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Splits the list into two before the current element. This will return a │ │ │ │ + A: Clone,

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Splits the list into two before the current element. This will return a │ │ │ │ new list consisting of everything before the cursor, with the original │ │ │ │ list retaining everything after.

    │ │ │ │

    If the cursor is pointing at the “ghost” non-element then the entire contents │ │ │ │ of the LinkedList are moved.

    │ │ │ │
    source

    pub fn push_front(&mut self, elt: T)

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Appends an element to the front of the cursor’s parent list. The node │ │ │ │ that the cursor points to is unchanged, even if it is the “ghost” node.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │
    source

    pub fn push_back(&mut self, elt: T)

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Appends an element to the back of the cursor’s parent list. The node │ │ │ │ that the cursor points to is unchanged, even if it is the “ghost” node.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │ -
    source

    pub fn pop_front(&mut self) -> Option<T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Removes the first element from the cursor’s parent list and returns it, │ │ │ │ +

    source

    pub fn pop_front(&mut self) -> Option<T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Removes the first element from the cursor’s parent list and returns it, │ │ │ │ or None if the list is empty. The element the cursor points to remains │ │ │ │ unchanged, unless it was pointing to the front element. In that case, it │ │ │ │ points to the new front element.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │ -
    source

    pub fn pop_back(&mut self) -> Option<T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Removes the last element from the cursor’s parent list and returns it, │ │ │ │ +

    source

    pub fn pop_back(&mut self) -> Option<T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Removes the last element from the cursor’s parent list and returns it, │ │ │ │ or None if the list is empty. The element the cursor points to remains │ │ │ │ unchanged, unless it was pointing to the back element. In that case, it │ │ │ │ points to the “ghost” element.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │ -
    source

    pub fn front(&self) -> Option<&T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a reference to the front element of the cursor’s parent list, │ │ │ │ +

    source

    pub fn front(&self) -> Option<&T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a reference to the front element of the cursor’s parent list, │ │ │ │ or None if the list is empty.

    │ │ │ │ -
    source

    pub fn front_mut(&mut self) -> Option<&mut T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a mutable reference to the front element of the cursor’s │ │ │ │ +

    source

    pub fn front_mut(&mut self) -> Option<&mut T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a mutable reference to the front element of the cursor’s │ │ │ │ parent list, or None if the list is empty.

    │ │ │ │ -
    source

    pub fn back(&self) -> Option<&T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a reference to the back element of the cursor’s parent list, │ │ │ │ +

    source

    pub fn back(&self) -> Option<&T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a reference to the back element of the cursor’s parent list, │ │ │ │ or None if the list is empty.

    │ │ │ │ -
    source

    pub fn back_mut(&mut self) -> Option<&mut T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a mutable reference to back element of the cursor’s parent │ │ │ │ +

    source

    pub fn back_mut(&mut self) -> Option<&mut T>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a mutable reference to back element of the cursor’s parent │ │ │ │ list, or None if the list is empty.

    │ │ │ │
    §Examples
    │ │ │ │

    Building and mutating a list with a cursor, then getting the back element:

    │ │ │ │ │ │ │ │ 
    #![feature(linked_list_cursors)]
│ │ │ │  use std::collections::LinkedList;
│ │ │ │  let mut dl = LinkedList::new();
│ │ │ │ @@ -106,20 +106,20 @@
│ │ │ │  *cursor.current().unwrap() = 99;
│ │ │ │  *cursor.back_mut().unwrap() = 0;
│ │ │ │  let mut contents = dl.into_iter();
│ │ │ │  assert_eq!(contents.next(), Some(99));
│ │ │ │  assert_eq!(contents.next(), Some(2));
│ │ │ │  assert_eq!(contents.next(), Some(0));
│ │ │ │  assert_eq!(contents.next(), None);
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: Debug, A: Allocator> Debug for CursorMut<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Send, A: Allocator + Send> Send for CursorMut<'_, T, A>

    source§

    impl<T: Sync, A: Allocator + Sync> Sync for CursorMut<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for CursorMut<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for CursorMut<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, A> Unpin for CursorMut<'a, T, A>

    §

    impl<'a, T, A = Global> !UnwindSafe for CursorMut<'a, T, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: Debug, A: Allocator> Debug for CursorMut<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Send, A: Allocator + Send> Send for CursorMut<'_, T, A>

    source§

    impl<T: Sync, A: Allocator + Sync> Sync for CursorMut<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for CursorMut<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for CursorMut<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, A> Unpin for CursorMut<'a, T, A>

    §

    impl<'a, T, A = Global> !UnwindSafe for CursorMut<'a, T, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.ExtractIf.html │ │ │ │ @@ -1,199 +1,199 @@ │ │ │ │ ExtractIf in alloc::collections::linked_list - Rust
    │ │ │ │

    Struct alloc::collections::linked_list::ExtractIf

    source · 
    pub struct ExtractIf<'a, T: 'a, F, A: Allocator = Global>
    where
│ │ │ │ -    F: FnMut(&mut T) -> bool + 'a,
    { /* private fields */ }
    🔬This is a nightly-only experimental API. (extract_if #43244)
    Expand description

    An iterator produced by calling extract_if on LinkedList.

    │ │ │ │ + F: FnMut(&mut T) -> bool + 'a,
    { /* private fields */ }
    🔬This is a nightly-only experimental API. (extract_if #43244)
    Expand description

    An iterator produced by calling extract_if on LinkedList.

    │ │ │ │

    Trait Implementations§

    source§

    impl<T: Debug, F> Debug for ExtractIf<'_, T, F>
    where │ │ │ │ - F: FnMut(&mut T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
    where │ │ │ │ - F: FnMut(&mut T) -> bool,

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + F: FnMut(&mut T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
    where │ │ │ │ + F: FnMut(&mut T) -> bool,

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more

    Auto Trait Implementations§

    §

    impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
    where │ │ │ │ - F: Freeze,

    §

    impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - F: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, F, A = Global> !Send for ExtractIf<'a, T, F, A>

    §

    impl<'a, T, F, A = Global> !Sync for ExtractIf<'a, T, F, A>

    §

    impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
    where │ │ │ │ - F: Unpin,

    §

    impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more

    Auto Trait Implementations§

    §

    impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
    where │ │ │ │ + F: Freeze,

    §

    impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + F: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, F, A = Global> !Send for ExtractIf<'a, T, F, A>

    §

    impl<'a, T, F, A = Global> !Sync for ExtractIf<'a, T, F, A>

    §

    impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
    where │ │ │ │ + F: Unpin,

    §

    impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.IntoIter.html │ │ │ │ @@ -1,226 +1,226 @@ │ │ │ │ IntoIter in alloc::collections::linked_list - Rust
    │ │ │ │

    Struct alloc::collections::linked_list::IntoIter

    1.0.0 · source · 
    pub struct IntoIter<T, A: Allocator = Global> { /* private fields */ }
    Expand description

    An owning iterator over the elements of a LinkedList.

    │ │ │ │

    This struct is created by the into_iter method on LinkedList │ │ │ │ -(provided by the IntoIterator trait). See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>

    source§

    fn clone(&self) -> IntoIter<T, A> ⓘ

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for IntoIter<T>

    source§

    fn default() -> Self

    Creates an empty linked_list::IntoIter.

    │ │ │ │ +(provided by the IntoIterator trait). See its documentation for more.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>

    source§

    fn clone(&self) -> IntoIter<T, A> ⓘ

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for IntoIter<T>

    source§

    fn default() -> Self

    Creates an empty linked_list::IntoIter.

    │ │ │ │ │ │ │ │ 
    let iter: linked_list::IntoIter<u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<T, A: Allocator> Iterator for IntoIter<T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<T, A: Allocator> Iterator for IntoIter<T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T, A: Allocator> FusedIterator for IntoIter<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for IntoIter<T, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<T, A> RefUnwindSafe for IntoIter<T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<T, A> Send for IntoIter<T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<T, A> Sync for IntoIter<T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<T, A> Unpin for IntoIter<T, A>
    where │ │ │ │ - A: Unpin,

    §

    impl<T, A> UnwindSafe for IntoIter<T, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - T: UnwindSafe + RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T, A: Allocator> FusedIterator for IntoIter<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for IntoIter<T, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<T, A> RefUnwindSafe for IntoIter<T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<T, A> Send for IntoIter<T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<T, A> Sync for IntoIter<T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<T, A> Unpin for IntoIter<T, A>
    where │ │ │ │ + A: Unpin,

    §

    impl<T, A> UnwindSafe for IntoIter<T, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + T: UnwindSafe + RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.Iter.html │ │ │ │ @@ -1,218 +1,218 @@ │ │ │ │ Iter in alloc::collections::linked_list - Rust
    │ │ │ │

    Struct alloc::collections::linked_list::Iter

    1.0.0 · source · 
    pub struct Iter<'a, T: 'a> { /* private fields */ }
    Expand description

    An iterator over the elements of a LinkedList.

    │ │ │ │

    This struct is created by LinkedList::iter(). See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T> Clone for Iter<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for Iter<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for Iter<'_, T>

    source§

    fn default() -> Self

    Creates an empty linked_list::Iter.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T> Clone for Iter<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for Iter<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for Iter<'_, T>

    source§

    fn default() -> Self

    Creates an empty linked_list::Iter.

    │ │ │ │ │ │ │ │ 
    let iter: linked_list::Iter<'_, u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    │ │ │ │ -
    source§

    impl<'a, T> DoubleEndedIterator for Iter<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for Iter<'_, T>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, T> Iterator for Iter<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    source§

    impl<'a, T> DoubleEndedIterator for Iter<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for Iter<'_, T>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, T> Iterator for Iter<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Iter<'_, T>

    source§

    impl<T: Sync> Send for Iter<'_, T>

    source§

    impl<T: Sync> Sync for Iter<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Iter<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Iter<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for Iter<'a, T>

    §

    impl<'a, T> UnwindSafe for Iter<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Iter<'_, T>

    source§

    impl<T: Sync> Send for Iter<'_, T>

    source§

    impl<T: Sync> Sync for Iter<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Iter<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Iter<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for Iter<'a, T>

    §

    impl<'a, T> UnwindSafe for Iter<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.IterMut.html │ │ │ │ @@ -1,211 +1,211 @@ │ │ │ │ IterMut in alloc::collections::linked_list - Rust
    │ │ │ │

    Struct alloc::collections::linked_list::IterMut

    1.0.0 · source · 
    pub struct IterMut<'a, T: 'a> { /* private fields */ }
    Expand description

    A mutable iterator over the elements of a LinkedList.

    │ │ │ │

    This struct is created by LinkedList::iter_mut(). See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    1.17.0 · source§

    impl<T: Debug> Debug for IterMut<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for IterMut<'_, T>

    source§

    fn default() -> Self

    Returns the “default value” for a type. Read more
    source§

    impl<'a, T> DoubleEndedIterator for IterMut<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a mut T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for IterMut<'_, T>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, T> Iterator for IterMut<'a, T>

    §

    type Item = &'a mut T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a mut T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    1.17.0 · source§

    impl<T: Debug> Debug for IterMut<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.70.0 · source§

    impl<T> Default for IterMut<'_, T>

    source§

    fn default() -> Self

    Returns the “default value” for a type. Read more
    source§

    impl<'a, T> DoubleEndedIterator for IterMut<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a mut T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for IterMut<'_, T>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, T> Iterator for IterMut<'a, T>

    §

    type Item = &'a mut T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn last(self) -> Option<&'a mut T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for IterMut<'_, T>

    source§

    impl<T: Send> Send for IterMut<'_, T>

    source§

    impl<T: Sync> Sync for IterMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for IterMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for IterMut<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for IterMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for IterMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for IterMut<'_, T>

    source§

    impl<T: Send> Send for IterMut<'_, T>

    source§

    impl<T: Sync> Sync for IterMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for IterMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for IterMut<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for IterMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for IterMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/linked_list/struct.LinkedList.html │ │ │ │ @@ -11,15 +11,15 @@ │ │ │ │ array-based containers are generally faster, │ │ │ │ more memory efficient, and make better use of CPU cache.

    │ │ │ │

    Implementations§

    source§

    impl<T> LinkedList<T>

    const: 1.39.0 · source

    pub const fn new() -> Self

    Creates an empty LinkedList.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let list: LinkedList<u32> = LinkedList::new();
    Run
    │ │ │ │ -
    source

    pub fn append(&mut self, other: &mut Self)

    Moves all elements from other to the end of the list.

    │ │ │ │ +
    source

    pub fn append(&mut self, other: &mut Self)

    Moves all elements from other to the end of the list.

    │ │ │ │

    This reuses all the nodes from other and moves them into self. After │ │ │ │ this operation, other becomes empty.

    │ │ │ │

    This operation should compute in O(1) time and O(1) memory.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let mut list1 = LinkedList::new();
│ │ │ │ @@ -84,25 +84,25 @@
│ │ │ │  
    The cursor is pointing to the “ghost” non-element if the list is empty.
    
│ │ │ │
    source

    pub fn cursor_front_mut(&mut self) -> CursorMut<'_, T, A>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a cursor with editing operations at the front element.

    │ │ │ │

    The cursor is pointing to the “ghost” non-element if the list is empty.

    │ │ │ │
    source

    pub fn cursor_back(&self) -> Cursor<'_, T, A>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a cursor at the back element.

    │ │ │ │

    The cursor is pointing to the “ghost” non-element if the list is empty.

    │ │ │ │
    source

    pub fn cursor_back_mut(&mut self) -> CursorMut<'_, T, A>

    🔬This is a nightly-only experimental API. (linked_list_cursors #58533)

    Provides a cursor with editing operations at the back element.

    │ │ │ │

    The cursor is pointing to the “ghost” non-element if the list is empty.

    │ │ │ │ -
    source

    pub fn is_empty(&self) -> bool

    Returns true if the LinkedList is empty.

    │ │ │ │ +
    source

    pub fn is_empty(&self) -> bool

    Returns true if the LinkedList is empty.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let mut dl = LinkedList::new();
│ │ │ │  assert!(dl.is_empty());
│ │ │ │  
│ │ │ │  dl.push_front("foo");
│ │ │ │  assert!(!dl.is_empty());
    Run
    │ │ │ │ -
    source

    pub fn len(&self) -> usize

    Returns the length of the LinkedList.

    │ │ │ │ +
    source

    pub fn len(&self) -> usize

    Returns the length of the LinkedList.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let mut dl = LinkedList::new();
│ │ │ │  
│ │ │ │  dl.push_front(2);
│ │ │ │ @@ -124,41 +124,41 @@
│ │ │ │  dl.push_front(1);
│ │ │ │  assert_eq!(dl.len(), 2);
│ │ │ │  assert_eq!(dl.front(), Some(&1));
│ │ │ │  
│ │ │ │  dl.clear();
│ │ │ │  assert_eq!(dl.len(), 0);
│ │ │ │  assert_eq!(dl.front(), None);
    Run
    │ │ │ │ -
    1.12.0 · source

    pub fn contains(&self, x: &T) -> bool
    where │ │ │ │ - T: PartialEq<T>,

    Returns true if the LinkedList contains an element equal to the │ │ │ │ +

    1.12.0 · source

    pub fn contains(&self, x: &T) -> bool
    where │ │ │ │ + T: PartialEq<T>,

    Returns true if the LinkedList contains an element equal to the │ │ │ │ given value.

    │ │ │ │

    This operation should compute linearly in O(n) time.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let mut list: LinkedList<u32> = LinkedList::new();
│ │ │ │  
│ │ │ │  list.push_back(0);
│ │ │ │  list.push_back(1);
│ │ │ │  list.push_back(2);
│ │ │ │  
│ │ │ │  assert_eq!(list.contains(&0), true);
│ │ │ │  assert_eq!(list.contains(&10), false);
    Run
    │ │ │ │ -
    source

    pub fn front(&self) -> Option<&T>

    Provides a reference to the front element, or None if the list is │ │ │ │ +

    source

    pub fn front(&self) -> Option<&T>

    Provides a reference to the front element, or None if the list is │ │ │ │ empty.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let mut dl = LinkedList::new();
│ │ │ │  assert_eq!(dl.front(), None);
│ │ │ │  
│ │ │ │  dl.push_front(1);
│ │ │ │  assert_eq!(dl.front(), Some(&1));
    Run
    │ │ │ │ -
    source

    pub fn front_mut(&mut self) -> Option<&mut T>

    Provides a mutable reference to the front element, or None if the list │ │ │ │ +

    source

    pub fn front_mut(&mut self) -> Option<&mut T>

    Provides a mutable reference to the front element, or None if the list │ │ │ │ is empty.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let mut dl = LinkedList::new();
│ │ │ │  assert_eq!(dl.front(), None);
│ │ │ │ @@ -167,26 +167,26 @@
│ │ │ │  assert_eq!(dl.front(), Some(&1));
│ │ │ │  
│ │ │ │  match dl.front_mut() {
│ │ │ │      None => {},
│ │ │ │      Some(x) => *x = 5,
│ │ │ │  }
│ │ │ │  assert_eq!(dl.front(), Some(&5));
    Run
    │ │ │ │ -
    source

    pub fn back(&self) -> Option<&T>

    Provides a reference to the back element, or None if the list is │ │ │ │ +

    source

    pub fn back(&self) -> Option<&T>

    Provides a reference to the back element, or None if the list is │ │ │ │ empty.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let mut dl = LinkedList::new();
│ │ │ │  assert_eq!(dl.back(), None);
│ │ │ │  
│ │ │ │  dl.push_back(1);
│ │ │ │  assert_eq!(dl.back(), Some(&1));
    Run
    │ │ │ │ -
    source

    pub fn back_mut(&mut self) -> Option<&mut T>

    Provides a mutable reference to the back element, or None if the list │ │ │ │ +

    source

    pub fn back_mut(&mut self) -> Option<&mut T>

    Provides a mutable reference to the back element, or None if the list │ │ │ │ is empty.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let mut dl = LinkedList::new();
│ │ │ │  assert_eq!(dl.back(), None);
│ │ │ │ @@ -207,15 +207,15 @@
│ │ │ │  let mut dl = LinkedList::new();
│ │ │ │  
│ │ │ │  dl.push_front(2);
│ │ │ │  assert_eq!(dl.front().unwrap(), &2);
│ │ │ │  
│ │ │ │  dl.push_front(1);
│ │ │ │  assert_eq!(dl.front().unwrap(), &1);
    Run
    │ │ │ │ -
    source

    pub fn pop_front(&mut self) -> Option<T>

    Removes the first element and returns it, or None if the list is │ │ │ │ +

    source

    pub fn pop_front(&mut self) -> Option<T>

    Removes the first element and returns it, or None if the list is │ │ │ │ empty.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let mut d = LinkedList::new();
│ │ │ │  assert_eq!(d.pop_front(), None);
│ │ │ │ @@ -230,27 +230,27 @@
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let mut d = LinkedList::new();
│ │ │ │  d.push_back(1);
│ │ │ │  d.push_back(3);
│ │ │ │  assert_eq!(3, *d.back().unwrap());
    Run
    
│ │ │ │ -
    source

    pub fn pop_back(&mut self) -> Option<T>

    Removes the last element from a list and returns it, or None if │ │ │ │ +

    source

    pub fn pop_back(&mut self) -> Option<T>

    Removes the last element from a list and returns it, or None if │ │ │ │ it is empty.

    │ │ │ │

    This operation should compute in O(1) time.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let mut d = LinkedList::new();
│ │ │ │  assert_eq!(d.pop_back(), None);
│ │ │ │  d.push_back(1);
│ │ │ │  d.push_back(3);
│ │ │ │  assert_eq!(d.pop_back(), Some(3));
    Run
    │ │ │ │ -
    source

    pub fn split_off(&mut self, at: usize) -> LinkedList<T, A>
    where │ │ │ │ - A: Clone,

    Splits the list into two at the given index. Returns everything after the given index, │ │ │ │ +

    source

    pub fn split_off(&mut self, at: usize) -> LinkedList<T, A>
    where │ │ │ │ + A: Clone,

    Splits the list into two at the given index. Returns everything after the given index, │ │ │ │ including the index.

    │ │ │ │

    This operation should compute in O(n) time.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if at > len.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │ @@ -260,15 +260,15 @@
│ │ │ │  d.push_front(2);
│ │ │ │  d.push_front(3);
│ │ │ │  
│ │ │ │  let mut split = d.split_off(2);
│ │ │ │  
│ │ │ │  assert_eq!(split.pop_front(), Some(1));
│ │ │ │  assert_eq!(split.pop_front(), None);
    Run
    │ │ │ │ -
    source

    pub fn remove(&mut self, at: usize) -> T

    🔬This is a nightly-only experimental API. (linked_list_remove #69210)

    Removes the element at the given index and returns it.

    │ │ │ │ +
    source

    pub fn remove(&mut self, at: usize) -> T

    🔬This is a nightly-only experimental API. (linked_list_remove #69210)

    Removes the element at the given index and returns it.

    │ │ │ │

    This operation should compute in O(n) time.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if at >= len

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(linked_list_remove)]
│ │ │ │  use std::collections::LinkedList;
│ │ │ │  
│ │ │ │ @@ -278,15 +278,15 @@
│ │ │ │  d.push_front(2);
│ │ │ │  d.push_front(3);
│ │ │ │  
│ │ │ │  assert_eq!(d.remove(1), 2);
│ │ │ │  assert_eq!(d.remove(0), 3);
│ │ │ │  assert_eq!(d.remove(0), 1);
    Run
    │ │ │ │
    source

    pub fn retain<F>(&mut self, f: F)
    where │ │ │ │ - F: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (linked_list_retain #114135)

    Retains only the elements specified by the predicate.

    │ │ │ │ + F: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (linked_list_retain #114135)

    Retains only the elements specified by the predicate.

    │ │ │ │

    In other words, remove all elements e for which f(&e) returns false. │ │ │ │ This method operates in place, visiting each element exactly once in the │ │ │ │ original order, and preserves the order of the retained elements.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(linked_list_retain)]
│ │ │ │  use std::collections::LinkedList;
│ │ │ │  
│ │ │ │ @@ -314,15 +314,15 @@
│ │ │ │  
│ │ │ │  let keep = [false, true, false];
│ │ │ │  let mut iter = keep.iter();
│ │ │ │  d.retain(|_| *iter.next().unwrap());
│ │ │ │  assert_eq!(d.pop_front(), Some(2));
│ │ │ │  assert_eq!(d.pop_front(), None);
    Run
    │ │ │ │
    source

    pub fn retain_mut<F>(&mut self, f: F)
    where │ │ │ │ - F: FnMut(&mut T) -> bool,

    🔬This is a nightly-only experimental API. (linked_list_retain #114135)

    Retains only the elements specified by the predicate.

    │ │ │ │ + F: FnMut(&mut T) -> bool,
    🔬This is a nightly-only experimental API. (linked_list_retain #114135)

    Retains only the elements specified by the predicate.

    │ │ │ │

    In other words, remove all elements e for which f(&e) returns false. │ │ │ │ This method operates in place, visiting each element exactly once in the │ │ │ │ original order, and preserves the order of the retained elements.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(linked_list_retain)]
│ │ │ │  use std::collections::LinkedList;
│ │ │ │  
│ │ │ │ @@ -337,15 +337,15 @@
│ │ │ │      true
│ │ │ │  } else {
│ │ │ │      false
│ │ │ │  });
│ │ │ │  assert_eq!(d.pop_front(), Some(3));
│ │ │ │  assert_eq!(d.pop_front(), None);
    Run
    │ │ │ │
    source

    pub fn extract_if<F>(&mut self, filter: F) -> ExtractIf<'_, T, F, A> ⓘ
    where │ │ │ │ - F: FnMut(&mut T) -> bool,

    🔬This is a nightly-only experimental API. (extract_if #43244)

    Creates an iterator which uses a closure to determine if an element should be removed.

    │ │ │ │ + F: FnMut(&mut T) -> bool,
    🔬This is a nightly-only experimental API. (extract_if #43244)

    Creates an iterator which uses a closure to determine if an element should be removed.

    │ │ │ │

    If the closure returns true, then the element is removed and yielded. │ │ │ │ If the closure returns false, the element will remain in the list and will not be yielded │ │ │ │ by the iterator.

    │ │ │ │

    If the returned ExtractIf is not exhausted, e.g. because it is dropped without iterating │ │ │ │ or the iteration short-circuits, then the remaining elements will be retained. │ │ │ │ Use extract_if().for_each(drop) if you do not need the returned iterator.

    │ │ │ │

    Note that extract_if lets you mutate every element in the filter closure, regardless of │ │ │ │ @@ -360,43 +360,43 @@ │ │ │ │ numbers.extend(&[1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]); │ │ │ │ │ │ │ │ let evens = numbers.extract_if(|x| *x % 2 == 0).collect::<LinkedList<_>>(); │ │ │ │ let odds = numbers; │ │ │ │ │ │ │ │ assert_eq!(evens.into_iter().collect::<Vec<_>>(), vec![2, 4, 6, 8, 14]); │ │ │ │ assert_eq!(odds.into_iter().collect::<Vec<_>>(), vec![1, 3, 5, 9, 11, 13, 15]);Run

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: Clone, A: Allocator + Clone> Clone for LinkedList<T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, other: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Debug, A: Allocator> Debug for LinkedList<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T> Default for LinkedList<T>

    source§

    fn default() -> Self

    Creates an empty LinkedList<T>.

    │ │ │ │ -
    source§

    impl<T, A: Allocator> Drop for LinkedList<T, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.2.0 · source§

    impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for LinkedList<T, A>

    source§

    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: &'a T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl<T, A: Allocator> Extend<T> for LinkedList<T, A>

    source§

    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.56.0 · source§

    impl<T, const N: usize> From<[T; N]> for LinkedList<T>

    source§

    fn from(arr: [T; N]) -> Self

    Converts a [T; N] into a LinkedList<T>.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: Clone, A: Allocator + Clone> Clone for LinkedList<T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, other: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Debug, A: Allocator> Debug for LinkedList<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T> Default for LinkedList<T>

    source§

    fn default() -> Self

    Creates an empty LinkedList<T>.

    │ │ │ │ +
    source§

    impl<T, A: Allocator> Drop for LinkedList<T, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.2.0 · source§

    impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for LinkedList<T, A>

    source§

    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: &'a T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl<T, A: Allocator> Extend<T> for LinkedList<T, A>

    source§

    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.56.0 · source§

    impl<T, const N: usize> From<[T; N]> for LinkedList<T>

    source§

    fn from(arr: [T; N]) -> Self

    Converts a [T; N] into a LinkedList<T>.

    │ │ │ │ │ │ │ │ 
    use std::collections::LinkedList;
│ │ │ │  
│ │ │ │  let list1 = LinkedList::from([1, 2, 3, 4]);
│ │ │ │  let list2: LinkedList<_> = [1, 2, 3, 4].into();
│ │ │ │  assert_eq!(list1, list2);
    Run
    │ │ │ │ -
    source§

    impl<T> FromIterator<T> for LinkedList<T>

    source§

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

    Creates a value from an iterator. Read more
    source§

    impl<T: Hash, A: Allocator> Hash for LinkedList<T, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ - H: Hasher, │ │ │ │ - Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<'a, T, A: Allocator> IntoIterator for &'a LinkedList<T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    §

    type IntoIter = Iter<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Iter<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<'a, T, A: Allocator> IntoIterator for &'a mut LinkedList<T, A>

    §

    type Item = &'a mut T

    The type of the elements being iterated over.
    §

    type IntoIter = IterMut<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> IterMut<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<T, A: Allocator> IntoIterator for LinkedList<T, A>

    source§

    fn into_iter(self) -> IntoIter<T, A> ⓘ

    Consumes the list into an iterator yielding elements by value.

    │ │ │ │ -
    §

    type Item = T

    The type of the elements being iterated over.
    §

    type IntoIter = IntoIter<T, A>

    Which kind of iterator are we turning this into?
    source§

    impl<T: Ord, A: Allocator> Ord for LinkedList<T, A>

    source§

    fn cmp(&self, other: &Self) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ - Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<T: PartialEq, A: Allocator> PartialEq for LinkedList<T, A>

    source§

    fn eq(&self, other: &Self) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Self) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<T: PartialOrd, A: Allocator> PartialOrd for LinkedList<T, A>

    source§

    fn partial_cmp(&self, other: &Self) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ -operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ -operator. Read more
    source§

    impl<T: Eq, A: Allocator> Eq for LinkedList<T, A>

    source§

    impl<T: Send, A: Allocator + Send> Send for LinkedList<T, A>

    source§

    impl<T: Sync, A: Allocator + Sync> Sync for LinkedList<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for LinkedList<T, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<T, A> RefUnwindSafe for LinkedList<T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<T, A> Unpin for LinkedList<T, A>
    where │ │ │ │ - A: Unpin,

    §

    impl<T, A> UnwindSafe for LinkedList<T, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - T: UnwindSafe + RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +
    source§

    impl<T> FromIterator<T> for LinkedList<T>

    source§

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

    Creates a value from an iterator. Read more
    source§

    impl<T: Hash, A: Allocator> Hash for LinkedList<T, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ + H: Hasher, │ │ │ │ + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<'a, T, A: Allocator> IntoIterator for &'a LinkedList<T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    §

    type IntoIter = Iter<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Iter<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<'a, T, A: Allocator> IntoIterator for &'a mut LinkedList<T, A>

    §

    type Item = &'a mut T

    The type of the elements being iterated over.
    §

    type IntoIter = IterMut<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> IterMut<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<T, A: Allocator> IntoIterator for LinkedList<T, A>

    source§

    fn into_iter(self) -> IntoIter<T, A> ⓘ

    Consumes the list into an iterator yielding elements by value.

    │ │ │ │ +
    §

    type Item = T

    The type of the elements being iterated over.
    §

    type IntoIter = IntoIter<T, A>

    Which kind of iterator are we turning this into?
    source§

    impl<T: Ord, A: Allocator> Ord for LinkedList<T, A>

    source§

    fn cmp(&self, other: &Self) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ + Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<T: PartialEq, A: Allocator> PartialEq for LinkedList<T, A>

    source§

    fn eq(&self, other: &Self) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Self) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<T: PartialOrd, A: Allocator> PartialOrd for LinkedList<T, A>

    source§

    fn partial_cmp(&self, other: &Self) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ +operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ +operator. Read more
    source§

    impl<T: Eq, A: Allocator> Eq for LinkedList<T, A>

    source§

    impl<T: Send, A: Allocator + Send> Send for LinkedList<T, A>

    source§

    impl<T: Sync, A: Allocator + Sync> Sync for LinkedList<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for LinkedList<T, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<T, A> RefUnwindSafe for LinkedList<T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<T, A> Unpin for LinkedList<T, A>
    where │ │ │ │ + A: Unpin,

    §

    impl<T, A> UnwindSafe for LinkedList<T, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + T: UnwindSafe + RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/struct.TryReserveError.html │ │ │ │ @@ -1,18 +1,18 @@ │ │ │ │ TryReserveError in alloc::collections - Rust
    │ │ │ │

    Struct alloc::collections::TryReserveError

    1.57.0 · source · 
    pub struct TryReserveError { /* private fields */ }
    Expand description

    The error type for try_reserve methods.

    │ │ │ │

    Implementations§

    source§

    impl TryReserveError

    source

    pub fn kind(&self) -> TryReserveErrorKind

    🔬This is a nightly-only experimental API. (try_reserve_kind #48043)

    Details about the allocation that caused the error

    │ │ │ │ -

    Trait Implementations§

    source§

    impl Clone for TryReserveError

    source§

    fn clone(&self) -> TryReserveError

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for TryReserveError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl Display for TryReserveError

    source§

    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl Error for TryReserveError

    1.30.0 · source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl From<TryReserveErrorKind> for TryReserveError

    source§

    fn from(kind: TryReserveErrorKind) -> Self

    Converts to this type from the input type.
    source§

    impl PartialEq for TryReserveError

    source§

    fn eq(&self, other: &TryReserveError) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for TryReserveError

    source§

    impl StructuralPartialEq for TryReserveError

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl Clone for TryReserveError

    source§

    fn clone(&self) -> TryReserveError

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for TryReserveError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl Display for TryReserveError

    source§

    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl Error for TryReserveError

    1.30.0 · source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl From<TryReserveErrorKind> for TryReserveError

    source§

    fn from(kind: TryReserveErrorKind) -> Self

    Converts to this type from the input type.
    source§

    impl PartialEq for TryReserveError

    source§

    fn eq(&self, other: &TryReserveError) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for TryReserveError

    source§

    impl StructuralPartialEq for TryReserveError

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.Drain.html │ │ │ │ @@ -1,215 +1,215 @@ │ │ │ │ Drain in alloc::collections::vec_deque - Rust
    │ │ │ │

    Struct alloc::collections::vec_deque::Drain

    1.6.0 · source · 
    pub struct Drain<'a, T: 'a, A: Allocator = Global> { /* private fields */ }
    Expand description

    A draining iterator over the elements of a VecDeque.

    │ │ │ │

    This struct is created by the drain method on VecDeque. See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for Drain<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator> Drop for Drain<'_, T, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    source§

    impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>

    1.0.0 · source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<T, A: Allocator> Iterator for Drain<'_, T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for Drain<'_, T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator> Drop for Drain<'_, T, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    source§

    impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>

    1.0.0 · source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<T, A: Allocator> Iterator for Drain<'_, T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>

    source§

    impl<T: Send, A: Allocator + Send> Send for Drain<'_, T, A>

    source§

    impl<T: Sync, A: Allocator + Sync> Sync for Drain<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for Drain<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, A> Unpin for Drain<'a, T, A>

    §

    impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>

    source§

    impl<T: Send, A: Allocator + Send> Send for Drain<'_, T, A>

    source§

    impl<T: Sync, A: Allocator + Sync> Sync for Drain<'_, T, A>

    Auto Trait Implementations§

    §

    impl<'a, T, A> Freeze for Drain<'a, T, A>

    §

    impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, A> Unpin for Drain<'a, T, A>

    §

    impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.IntoIter.html │ │ │ │ @@ -1,216 +1,216 @@ │ │ │ │ IntoIter in alloc::collections::vec_deque - Rust
    │ │ │ │

    Struct alloc::collections::vec_deque::IntoIter

    1.0.0 · source · 
    pub struct IntoIter<T, A: Allocator = Global> { /* private fields */ }
    Expand description

    An owning iterator over the elements of a VecDeque.

    │ │ │ │

    This struct is created by the into_iter method on VecDeque │ │ │ │ -(provided by the IntoIterator trait). See its documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>

    source§

    fn clone(&self) -> IntoIter<T, A> ⓘ

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>

    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    impl<T, A: Allocator> Iterator for IntoIter<T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn count(self) -> usize

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    source§

    fn last(self) -> Option<Self::Item>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +(provided by the IntoIterator trait). See its documentation for more.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>

    source§

    fn clone(&self) -> IntoIter<T, A> ⓘ

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>

    source§

    fn next_back(&mut self) -> Option<T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>

    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    impl<T, A: Allocator> Iterator for IntoIter<T, A>

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<T>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn count(self) -> usize

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    source§

    fn last(self) -> Option<Self::Item>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T, A: Allocator> FusedIterator for IntoIter<T, A>

    source§

    impl<T, A: Allocator> TrustedLen for IntoIter<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for IntoIter<T, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<T, A> RefUnwindSafe for IntoIter<T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<T, A> Send for IntoIter<T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<T, A> Sync for IntoIter<T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<T, A> Unpin for IntoIter<T, A>
    where │ │ │ │ - A: Unpin, │ │ │ │ - T: Unpin,

    §

    impl<T, A> UnwindSafe for IntoIter<T, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T, A: Allocator> FusedIterator for IntoIter<T, A>

    source§

    impl<T, A: Allocator> TrustedLen for IntoIter<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for IntoIter<T, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<T, A> RefUnwindSafe for IntoIter<T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<T, A> Send for IntoIter<T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<T, A> Sync for IntoIter<T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<T, A> Unpin for IntoIter<T, A>
    where │ │ │ │ + A: Unpin, │ │ │ │ + T: Unpin,

    §

    impl<T, A> UnwindSafe for IntoIter<T, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.Iter.html │ │ │ │ @@ -1,212 +1,212 @@ │ │ │ │ Iter in alloc::collections::vec_deque - Rust
    │ │ │ │

    Struct alloc::collections::vec_deque::Iter

    1.0.0 · source · 
    pub struct Iter<'a, T: 'a> { /* private fields */ }
    Expand description

    An iterator over the elements of a VecDeque.

    │ │ │ │

    This struct is created by the iter method on super::VecDeque. See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T> Clone for Iter<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for Iter<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T> DoubleEndedIterator for Iter<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    source§

    fn rfold<Acc, F>(self, accum: Acc, f: F) -> Acc
    where │ │ │ │ - F: FnMut(Acc, Self::Item) -> Acc,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for Iter<'_, T>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, T> Iterator for Iter<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn fold<Acc, F>(self, accum: Acc, f: F) -> Acc
    where │ │ │ │ - F: FnMut(Acc, Self::Item) -> Acc,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    source§

    fn last(self) -> Option<&'a T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    source§

    impl<T> Clone for Iter<'_, T>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.17.0 · source§

    impl<T: Debug> Debug for Iter<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T> DoubleEndedIterator for Iter<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    source§

    fn rfold<Acc, F>(self, accum: Acc, f: F) -> Acc
    where │ │ │ │ + F: FnMut(Acc, Self::Item) -> Acc,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for Iter<'_, T>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, T> Iterator for Iter<'a, T>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a T>

    Advances the iterator and returns the next value. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn fold<Acc, F>(self, accum: Acc, f: F) -> Acc
    where │ │ │ │ + F: FnMut(Acc, Self::Item) -> Acc,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    source§

    fn last(self) -> Option<&'a T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Iter<'_, T>

    source§

    impl<T> TrustedLen for Iter<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Iter<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Iter<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for Iter<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Sync for Iter<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for Iter<'a, T>

    §

    impl<'a, T> UnwindSafe for Iter<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Iter<'_, T>

    source§

    impl<T> TrustedLen for Iter<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Iter<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Iter<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for Iter<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Sync for Iter<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for Iter<'a, T>

    §

    impl<'a, T> UnwindSafe for Iter<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.IterMut.html │ │ │ │ @@ -1,209 +1,209 @@ │ │ │ │ IterMut in alloc::collections::vec_deque - Rust
    │ │ │ │

    Struct alloc::collections::vec_deque::IterMut

    1.0.0 · source · 
    pub struct IterMut<'a, T: 'a> { /* private fields */ }
    Expand description

    A mutable iterator over the elements of a VecDeque.

    │ │ │ │

    This struct is created by the iter_mut method on super::VecDeque. See its │ │ │ │ documentation for more.

    │ │ │ │ -

    Trait Implementations§

    1.17.0 · source§

    impl<T: Debug> Debug for IterMut<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T> DoubleEndedIterator for IterMut<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a mut T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    source§

    fn rfold<Acc, F>(self, accum: Acc, f: F) -> Acc
    where │ │ │ │ - F: FnMut(Acc, Self::Item) -> Acc,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for IterMut<'_, T>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, T> Iterator for IterMut<'a, T>

    §

    type Item = &'a mut T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut T>

    Advances the iterator and returns the next value. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn fold<Acc, F>(self, accum: Acc, f: F) -> Acc
    where │ │ │ │ - F: FnMut(Acc, Self::Item) -> Acc,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    source§

    fn last(self) -> Option<&'a mut T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    1.17.0 · source§

    impl<T: Debug> Debug for IterMut<'_, T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T> DoubleEndedIterator for IterMut<'a, T>

    source§

    fn next_back(&mut self) -> Option<&'a mut T>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    source§

    fn rfold<Acc, F>(self, accum: Acc, f: F) -> Acc
    where │ │ │ │ + F: FnMut(Acc, Self::Item) -> Acc,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<T> ExactSizeIterator for IterMut<'_, T>

    source§

    fn len(&self) -> usize

    Returns the exact remaining length of the iterator. Read more
    source§

    fn is_empty(&self) -> bool

    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§

    impl<'a, T> Iterator for IterMut<'a, T>

    §

    type Item = &'a mut T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut T>

    Advances the iterator and returns the next value. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn fold<Acc, F>(self, accum: Acc, f: F) -> Acc
    where │ │ │ │ + F: FnMut(Acc, Self::Item) -> Acc,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    source§

    fn last(self) -> Option<&'a mut T>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for IterMut<'_, T>

    source§

    impl<T> TrustedLen for IterMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for IterMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for IterMut<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for IterMut<'a, T>
    where │ │ │ │ - T: Send,

    §

    impl<'a, T> Sync for IterMut<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for IterMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for IterMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for IterMut<'_, T>

    source§

    impl<T> TrustedLen for IterMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for IterMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for IterMut<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for IterMut<'a, T>
    where │ │ │ │ + T: Send,

    §

    impl<'a, T> Sync for IterMut<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for IterMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for IterMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/collections/vec_deque/struct.VecDeque.html │ │ │ │ @@ -15,114 +15,114 @@ │ │ │ │ so that its elements do not wrap, and returns a mutable slice to the │ │ │ │ now-contiguous element sequence.

    │ │ │ │

    Implementations§

    source§

    impl<T> VecDeque<T>

    const: 1.68.0 · source

    pub const fn new() -> VecDeque<T>

    Creates an empty deque.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let deque: VecDeque<u32> = VecDeque::new();
    Run
    │ │ │ │ -
    source

    pub fn with_capacity(capacity: usize) -> VecDeque<T>

    Creates an empty deque with space for at least capacity elements.

    │ │ │ │ +
    source

    pub fn with_capacity(capacity: usize) -> VecDeque<T>

    Creates an empty deque with space for at least capacity elements.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let deque: VecDeque<u32> = VecDeque::with_capacity(10);
    Run
    │ │ │ │
    source

    pub fn try_with_capacity( │ │ │ │ - capacity: usize │ │ │ │ -) -> Result<VecDeque<T>, TryReserveError>

    🔬This is a nightly-only experimental API. (try_with_capacity #91913)

    Creates an empty deque with space for at least capacity elements.

    │ │ │ │ + capacity: usize │ │ │ │ +) -> Result<VecDeque<T>, TryReserveError>
    🔬This is a nightly-only experimental API. (try_with_capacity #91913)

    Creates an empty deque with space for at least capacity elements.

    │ │ │ │
    §Errors
    │ │ │ │

    Returns an error if the capacity exceeds isize::MAX bytes, │ │ │ │ or if the allocator reports allocation failure.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let deque: VecDeque<u32> = VecDeque::try_with_capacity(10)?;
    Run
    │ │ │ │
    source§

    impl<T, A: Allocator> VecDeque<T, A>

    source

    pub const fn new_in(alloc: A) -> VecDeque<T, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Creates an empty deque.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let deque: VecDeque<u32> = VecDeque::new();
    Run
    │ │ │ │ -
    source

    pub fn with_capacity_in(capacity: usize, alloc: A) -> VecDeque<T, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Creates an empty deque with space for at least capacity elements.

    │ │ │ │ +
    source

    pub fn with_capacity_in(capacity: usize, alloc: A) -> VecDeque<T, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Creates an empty deque with space for at least capacity elements.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let deque: VecDeque<u32> = VecDeque::with_capacity(10);
    Run
    │ │ │ │ -
    source

    pub fn get(&self, index: usize) -> Option<&T>

    Provides a reference to the element at the given index.

    │ │ │ │ +
    source

    pub fn get(&self, index: usize) -> Option<&T>

    Provides a reference to the element at the given index.

    │ │ │ │

    Element at index 0 is the front of the queue.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::new();
│ │ │ │  buf.push_back(3);
│ │ │ │  buf.push_back(4);
│ │ │ │  buf.push_back(5);
│ │ │ │  buf.push_back(6);
│ │ │ │  assert_eq!(buf.get(1), Some(&4));
    Run
    │ │ │ │ -
    source

    pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

    Provides a mutable reference to the element at the given index.

    │ │ │ │ +
    source

    pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

    Provides a mutable reference to the element at the given index.

    │ │ │ │

    Element at index 0 is the front of the queue.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::new();
│ │ │ │  buf.push_back(3);
│ │ │ │  buf.push_back(4);
│ │ │ │  buf.push_back(5);
│ │ │ │  buf.push_back(6);
│ │ │ │  assert_eq!(buf[1], 4);
│ │ │ │  if let Some(elem) = buf.get_mut(1) {
│ │ │ │      *elem = 7;
│ │ │ │  }
│ │ │ │  assert_eq!(buf[1], 7);
    Run
    │ │ │ │ -
    source

    pub fn swap(&mut self, i: usize, j: usize)

    Swaps elements at indices i and j.

    │ │ │ │ +
    source

    pub fn swap(&mut self, i: usize, j: usize)

    Swaps elements at indices i and j.

    │ │ │ │

    i and j may be equal.

    │ │ │ │

    Element at index 0 is the front of the queue.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if either index is out of bounds.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::new();
│ │ │ │  buf.push_back(3);
│ │ │ │  buf.push_back(4);
│ │ │ │  buf.push_back(5);
│ │ │ │  assert_eq!(buf, [3, 4, 5]);
│ │ │ │  buf.swap(0, 2);
│ │ │ │  assert_eq!(buf, [5, 4, 3]);
    Run
    │ │ │ │ -
    source

    pub fn capacity(&self) -> usize

    Returns the number of elements the deque can hold without │ │ │ │ +

    source

    pub fn capacity(&self) -> usize

    Returns the number of elements the deque can hold without │ │ │ │ reallocating.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let buf: VecDeque<i32> = VecDeque::with_capacity(10);
│ │ │ │  assert!(buf.capacity() >= 10);
    Run
    │ │ │ │ -
    source

    pub fn reserve_exact(&mut self, additional: usize)

    Reserves the minimum capacity for at least additional more elements to be inserted in the │ │ │ │ +

    source

    pub fn reserve_exact(&mut self, additional: usize)

    Reserves the minimum capacity for at least additional more elements to be inserted in the │ │ │ │ given deque. Does nothing if the capacity is already sufficient.

    │ │ │ │

    Note that the allocator may give the collection more space than it requests. Therefore │ │ │ │ capacity can not be relied upon to be precisely minimal. Prefer reserve if future │ │ │ │ insertions are expected.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if the new capacity overflows usize.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf: VecDeque<i32> = [1].into();
│ │ │ │  buf.reserve_exact(10);
│ │ │ │  assert!(buf.capacity() >= 11);
    Run
    │ │ │ │ -
    source

    pub fn reserve(&mut self, additional: usize)

    Reserves capacity for at least additional more elements to be inserted in the given │ │ │ │ +

    source

    pub fn reserve(&mut self, additional: usize)

    Reserves capacity for at least additional more elements to be inserted in the given │ │ │ │ deque. The collection may reserve more space to speculatively avoid frequent reallocations.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if the new capacity overflows usize.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf: VecDeque<i32> = [1].into();
│ │ │ │  buf.reserve(10);
│ │ │ │  assert!(buf.capacity() >= 11);
    Run
    │ │ │ │
    1.57.0 · source

    pub fn try_reserve_exact( │ │ │ │ &mut self, │ │ │ │ - additional: usize │ │ │ │ -) -> Result<(), TryReserveError>

    Tries to reserve the minimum capacity for at least additional more elements to │ │ │ │ + additional: usize │ │ │ │ +) -> Result<(), TryReserveError>

    Tries to reserve the minimum capacity for at least additional more elements to │ │ │ │ be inserted in the given deque. After calling try_reserve_exact, │ │ │ │ capacity will be greater than or equal to self.len() + additional if │ │ │ │ it returns Ok(()). Does nothing if the capacity is already sufficient.

    │ │ │ │

    Note that the allocator may give the collection more space than it │ │ │ │ requests. Therefore, capacity can not be relied upon to be precisely │ │ │ │ minimal. Prefer try_reserve if future insertions are expected.

    │ │ │ │
    §Errors
    │ │ │ │ @@ -141,15 +141,15 @@ │ │ │ │ // Now we know this can't OOM(Out-Of-Memory) in the middle of our complex work │ │ │ │ output.extend(data.iter().map(|&val| { │ │ │ │ val * 2 + 5 // very complicated │ │ │ │ })); │ │ │ │ │ │ │ │ Ok(output) │ │ │ │ }    Run
    │ │ │ │ -
    1.57.0 · source

    pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

    Tries to reserve capacity for at least additional more elements to be inserted │ │ │ │ +

    1.57.0 · source

    pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

    Tries to reserve capacity for at least additional more elements to be inserted │ │ │ │ in the given deque. The collection may reserve more space to speculatively avoid │ │ │ │ frequent reallocations. After calling try_reserve, capacity will be │ │ │ │ greater than or equal to self.len() + additional if it returns │ │ │ │ Ok(()). Does nothing if capacity is already sufficient. This method │ │ │ │ preserves the contents even if an error occurs.

    │ │ │ │
    §Errors
    │ │ │ │

    If the capacity overflows usize, or the allocator reports a failure, then an error │ │ │ │ @@ -178,43 +178,43 @@ │ │ │ │ 

    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::with_capacity(15);
│ │ │ │  buf.extend(0..4);
│ │ │ │  assert_eq!(buf.capacity(), 15);
│ │ │ │  buf.shrink_to_fit();
│ │ │ │  assert!(buf.capacity() >= 4);
    Run
    │ │ │ │ -
    1.56.0 · source

    pub fn shrink_to(&mut self, min_capacity: usize)

    Shrinks the capacity of the deque with a lower bound.

    │ │ │ │ +
    1.56.0 · source

    pub fn shrink_to(&mut self, min_capacity: usize)

    Shrinks the capacity of the deque with a lower bound.

    │ │ │ │

    The capacity will remain at least as large as both the length │ │ │ │ and the supplied value.

    │ │ │ │

    If the current capacity is less than the lower limit, this is a no-op.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::with_capacity(15);
│ │ │ │  buf.extend(0..4);
│ │ │ │  assert_eq!(buf.capacity(), 15);
│ │ │ │  buf.shrink_to(6);
│ │ │ │  assert!(buf.capacity() >= 6);
│ │ │ │  buf.shrink_to(0);
│ │ │ │  assert!(buf.capacity() >= 4);
    Run
    │ │ │ │ -
    1.16.0 · source

    pub fn truncate(&mut self, len: usize)

    Shortens the deque, keeping the first len elements and dropping │ │ │ │ +

    1.16.0 · source

    pub fn truncate(&mut self, len: usize)

    Shortens the deque, keeping the first len elements and dropping │ │ │ │ the rest.

    │ │ │ │

    If len is greater or equal to the deque’s current length, this has │ │ │ │ no effect.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::new();
│ │ │ │  buf.push_back(5);
│ │ │ │  buf.push_back(10);
│ │ │ │  buf.push_back(15);
│ │ │ │  assert_eq!(buf, [5, 10, 15]);
│ │ │ │  buf.truncate(1);
│ │ │ │  assert_eq!(buf, [5]);
    Run
    │ │ │ │ -
    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ +
    source

    pub fn allocator(&self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │
    source

    pub fn iter(&self) -> Iter<'_, T> ⓘ

    Returns a front-to-back iterator.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::new();
│ │ │ │  buf.push_back(5);
│ │ │ │  buf.push_back(3);
│ │ │ │ @@ -231,15 +231,15 @@
│ │ │ │  buf.push_back(3);
│ │ │ │  buf.push_back(4);
│ │ │ │  for num in buf.iter_mut() {
│ │ │ │      *num = *num - 2;
│ │ │ │  }
│ │ │ │  let b: &[_] = &[&mut 3, &mut 1, &mut 2];
│ │ │ │  assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[..], b);
    Run
    │ │ │ │ -
    1.5.0 · source

    pub fn as_slices(&self) -> (&[T], &[T])

    Returns a pair of slices which contain, in order, the contents of the │ │ │ │ +

    1.5.0 · source

    pub fn as_slices(&self) -> (&[T], &[T])

    Returns a pair of slices which contain, in order, the contents of the │ │ │ │ deque.

    │ │ │ │

    If make_contiguous was previously called, all elements of the │ │ │ │ deque will be in the first slice and the second slice will be empty.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut deque = VecDeque::new();
│ │ │ │ @@ -250,15 +250,15 @@
│ │ │ │  
│ │ │ │  assert_eq!(deque.as_slices(), (&[0, 1, 2][..], &[][..]));
│ │ │ │  
│ │ │ │  deque.push_front(10);
│ │ │ │  deque.push_front(9);
│ │ │ │  
│ │ │ │  assert_eq!(deque.as_slices(), (&[9, 10][..], &[0, 1, 2][..]));
    Run
    │ │ │ │ -
    1.5.0 · source

    pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T])

    Returns a pair of slices which contain, in order, the contents of the │ │ │ │ +

    1.5.0 · source

    pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T])

    Returns a pair of slices which contain, in order, the contents of the │ │ │ │ deque.

    │ │ │ │

    If make_contiguous was previously called, all elements of the │ │ │ │ deque will be in the first slice and the second slice will be empty.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut deque = VecDeque::new();
│ │ │ │ @@ -268,47 +268,47 @@
│ │ │ │  
│ │ │ │  deque.push_front(10);
│ │ │ │  deque.push_front(9);
│ │ │ │  
│ │ │ │  deque.as_mut_slices().0[0] = 42;
│ │ │ │  deque.as_mut_slices().1[0] = 24;
│ │ │ │  assert_eq!(deque.as_slices(), (&[42, 10][..], &[24, 1][..]));
    Run
    │ │ │ │ -
    source

    pub fn len(&self) -> usize

    Returns the number of elements in the deque.

    │ │ │ │ +
    source

    pub fn len(&self) -> usize

    Returns the number of elements in the deque.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut deque = VecDeque::new();
│ │ │ │  assert_eq!(deque.len(), 0);
│ │ │ │  deque.push_back(1);
│ │ │ │  assert_eq!(deque.len(), 1);
    Run
    │ │ │ │ -
    source

    pub fn is_empty(&self) -> bool

    Returns true if the deque is empty.

    │ │ │ │ +
    source

    pub fn is_empty(&self) -> bool

    Returns true if the deque is empty.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut deque = VecDeque::new();
│ │ │ │  assert!(deque.is_empty());
│ │ │ │  deque.push_front(1);
│ │ │ │  assert!(!deque.is_empty());
    Run
    │ │ │ │
    1.51.0 · source

    pub fn range<R>(&self, range: R) -> Iter<'_, T> ⓘ
    where │ │ │ │ - R: RangeBounds<usize>,

    Creates an iterator that covers the specified range in the deque.

    │ │ │ │ + R: RangeBounds<usize>,

    Creates an iterator that covers the specified range in the deque.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if the starting point is greater than the end point or if │ │ │ │ the end point is greater than the length of the deque.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let deque: VecDeque<_> = [1, 2, 3].into();
│ │ │ │  let range = deque.range(2..).copied().collect::<VecDeque<_>>();
│ │ │ │  assert_eq!(range, [3]);
│ │ │ │  
│ │ │ │  // A full range covers all contents
│ │ │ │  let all = deque.range(..);
│ │ │ │  assert_eq!(all.len(), 3);
    Run
    │ │ │ │
    1.51.0 · source

    pub fn range_mut<R>(&mut self, range: R) -> IterMut<'_, T> ⓘ
    where │ │ │ │ - R: RangeBounds<usize>,

    Creates an iterator that covers the specified mutable range in the deque.

    │ │ │ │ + R: RangeBounds<usize>,

    Creates an iterator that covers the specified mutable range in the deque.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if the starting point is greater than the end point or if │ │ │ │ the end point is greater than the length of the deque.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut deque: VecDeque<_> = [1, 2, 3].into();
│ │ │ │ @@ -319,25 +319,25 @@
│ │ │ │  
│ │ │ │  // A full range covers all contents
│ │ │ │  for v in deque.range_mut(..) {
│ │ │ │    *v *= 2;
│ │ │ │  }
│ │ │ │  assert_eq!(deque, [2, 4, 12]);
    Run
    │ │ │ │
    1.6.0 · source

    pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A> ⓘ
    where │ │ │ │ - R: RangeBounds<usize>,

    Removes the specified range from the deque in bulk, returning all │ │ │ │ + R: RangeBounds<usize>,

    Removes the specified range from the deque in bulk, returning all │ │ │ │ removed elements as an iterator. If the iterator is dropped before │ │ │ │ being fully consumed, it drops the remaining removed elements.

    │ │ │ │

    The returned iterator keeps a mutable borrow on the queue to optimize │ │ │ │ its implementation.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if the starting point is greater than the end point or if │ │ │ │ the end point is greater than the length of the deque.

    │ │ │ │
    §Leaking
    │ │ │ │

    If the returned iterator goes out of scope without being dropped (due to │ │ │ │ -mem::forget, for example), the deque may have lost and leaked │ │ │ │ +mem::forget, for example), the deque may have lost and leaked │ │ │ │ elements arbitrarily, including elements outside the range.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut deque: VecDeque<_> = [1, 2, 3].into();
│ │ │ │  let drained = deque.drain(2..).collect::<VecDeque<_>>();
│ │ │ │  assert_eq!(drained, [3]);
│ │ │ │ @@ -350,94 +350,94 @@
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut deque = VecDeque::new();
│ │ │ │  deque.push_back(1);
│ │ │ │  deque.clear();
│ │ │ │  assert!(deque.is_empty());
    Run
    
│ │ │ │ -
    1.12.0 · source

    pub fn contains(&self, x: &T) -> bool
    where │ │ │ │ - T: PartialEq<T>,

    Returns true if the deque contains an element equal to the │ │ │ │ +

    1.12.0 · source

    pub fn contains(&self, x: &T) -> bool
    where │ │ │ │ + T: PartialEq<T>,

    Returns true if the deque contains an element equal to the │ │ │ │ given value.

    │ │ │ │

    This operation is O(n).

    │ │ │ │

    Note that if you have a sorted VecDeque, binary_search may be faster.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut deque: VecDeque<u32> = VecDeque::new();
│ │ │ │  
│ │ │ │  deque.push_back(0);
│ │ │ │  deque.push_back(1);
│ │ │ │  
│ │ │ │  assert_eq!(deque.contains(&1), true);
│ │ │ │  assert_eq!(deque.contains(&10), false);
    Run
    │ │ │ │ -
    source

    pub fn front(&self) -> Option<&T>

    Provides a reference to the front element, or None if the deque is │ │ │ │ +

    source

    pub fn front(&self) -> Option<&T>

    Provides a reference to the front element, or None if the deque is │ │ │ │ empty.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut d = VecDeque::new();
│ │ │ │  assert_eq!(d.front(), None);
│ │ │ │  
│ │ │ │  d.push_back(1);
│ │ │ │  d.push_back(2);
│ │ │ │  assert_eq!(d.front(), Some(&1));
    Run
    │ │ │ │ -
    source

    pub fn front_mut(&mut self) -> Option<&mut T>

    Provides a mutable reference to the front element, or None if the │ │ │ │ +

    source

    pub fn front_mut(&mut self) -> Option<&mut T>

    Provides a mutable reference to the front element, or None if the │ │ │ │ deque is empty.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut d = VecDeque::new();
│ │ │ │  assert_eq!(d.front_mut(), None);
│ │ │ │  
│ │ │ │  d.push_back(1);
│ │ │ │  d.push_back(2);
│ │ │ │  match d.front_mut() {
│ │ │ │      Some(x) => *x = 9,
│ │ │ │      None => (),
│ │ │ │  }
│ │ │ │  assert_eq!(d.front(), Some(&9));
    Run
    │ │ │ │ -
    source

    pub fn back(&self) -> Option<&T>

    Provides a reference to the back element, or None if the deque is │ │ │ │ +

    source

    pub fn back(&self) -> Option<&T>

    Provides a reference to the back element, or None if the deque is │ │ │ │ empty.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut d = VecDeque::new();
│ │ │ │  assert_eq!(d.back(), None);
│ │ │ │  
│ │ │ │  d.push_back(1);
│ │ │ │  d.push_back(2);
│ │ │ │  assert_eq!(d.back(), Some(&2));
    Run
    │ │ │ │ -
    source

    pub fn back_mut(&mut self) -> Option<&mut T>

    Provides a mutable reference to the back element, or None if the │ │ │ │ +

    source

    pub fn back_mut(&mut self) -> Option<&mut T>

    Provides a mutable reference to the back element, or None if the │ │ │ │ deque is empty.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut d = VecDeque::new();
│ │ │ │  assert_eq!(d.back(), None);
│ │ │ │  
│ │ │ │  d.push_back(1);
│ │ │ │  d.push_back(2);
│ │ │ │  match d.back_mut() {
│ │ │ │      Some(x) => *x = 9,
│ │ │ │      None => (),
│ │ │ │  }
│ │ │ │  assert_eq!(d.back(), Some(&9));
    Run
    │ │ │ │ -
    source

    pub fn pop_front(&mut self) -> Option<T>

    Removes the first element and returns it, or None if the deque is │ │ │ │ +

    source

    pub fn pop_front(&mut self) -> Option<T>

    Removes the first element and returns it, or None if the deque is │ │ │ │ empty.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut d = VecDeque::new();
│ │ │ │  d.push_back(1);
│ │ │ │  d.push_back(2);
│ │ │ │  
│ │ │ │  assert_eq!(d.pop_front(), Some(1));
│ │ │ │  assert_eq!(d.pop_front(), Some(2));
│ │ │ │  assert_eq!(d.pop_front(), None);
    Run
    │ │ │ │ -
    source

    pub fn pop_back(&mut self) -> Option<T>

    Removes the last element from the deque and returns it, or None if │ │ │ │ +

    source

    pub fn pop_back(&mut self) -> Option<T>

    Removes the last element from the deque and returns it, or None if │ │ │ │ it is empty.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::new();
│ │ │ │  assert_eq!(buf.pop_back(), None);
│ │ │ │  buf.push_back(1);
│ │ │ │ @@ -455,15 +455,15 @@
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::new();
│ │ │ │  buf.push_back(1);
│ │ │ │  buf.push_back(3);
│ │ │ │  assert_eq!(3, *buf.back().unwrap());
    Run
    
│ │ │ │ -
    1.5.0 · source

    pub fn swap_remove_front(&mut self, index: usize) -> Option<T>

    Removes an element from anywhere in the deque and returns it, │ │ │ │ +

    1.5.0 · source

    pub fn swap_remove_front(&mut self, index: usize) -> Option<T>

    Removes an element from anywhere in the deque and returns it, │ │ │ │ replacing it with the first element.

    │ │ │ │

    This does not preserve ordering, but is O(1).

    │ │ │ │

    Returns None if index is out of bounds.

    │ │ │ │

    Element at index 0 is the front of the queue.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │ @@ -472,15 +472,15 @@
│ │ │ │  buf.push_back(1);
│ │ │ │  buf.push_back(2);
│ │ │ │  buf.push_back(3);
│ │ │ │  assert_eq!(buf, [1, 2, 3]);
│ │ │ │  
│ │ │ │  assert_eq!(buf.swap_remove_front(2), Some(3));
│ │ │ │  assert_eq!(buf, [2, 1]);
    Run
    │ │ │ │ -
    1.5.0 · source

    pub fn swap_remove_back(&mut self, index: usize) -> Option<T>

    Removes an element from anywhere in the deque and returns it, │ │ │ │ +

    1.5.0 · source

    pub fn swap_remove_back(&mut self, index: usize) -> Option<T>

    Removes an element from anywhere in the deque and returns it, │ │ │ │ replacing it with the last element.

    │ │ │ │

    This does not preserve ordering, but is O(1).

    │ │ │ │

    Returns None if index is out of bounds.

    │ │ │ │

    Element at index 0 is the front of the queue.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │ @@ -489,15 +489,15 @@
│ │ │ │  buf.push_back(1);
│ │ │ │  buf.push_back(2);
│ │ │ │  buf.push_back(3);
│ │ │ │  assert_eq!(buf, [1, 2, 3]);
│ │ │ │  
│ │ │ │  assert_eq!(buf.swap_remove_back(0), Some(1));
│ │ │ │  assert_eq!(buf, [3, 2]);
    Run
    │ │ │ │ -
    1.5.0 · source

    pub fn insert(&mut self, index: usize, value: T)

    Inserts an element at index within the deque, shifting all elements │ │ │ │ +

    1.5.0 · source

    pub fn insert(&mut self, index: usize, value: T)

    Inserts an element at index within the deque, shifting all elements │ │ │ │ with indices greater than or equal to index towards the back.

    │ │ │ │

    Element at index 0 is the front of the queue.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if index is greater than deque’s length

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │ @@ -505,15 +505,15 @@
│ │ │ │  vec_deque.push_back('a');
│ │ │ │  vec_deque.push_back('b');
│ │ │ │  vec_deque.push_back('c');
│ │ │ │  assert_eq!(vec_deque, &['a', 'b', 'c']);
│ │ │ │  
│ │ │ │  vec_deque.insert(1, 'd');
│ │ │ │  assert_eq!(vec_deque, &['a', 'd', 'b', 'c']);
    Run
    │ │ │ │ -
    source

    pub fn remove(&mut self, index: usize) -> Option<T>

    Removes and returns the element at index from the deque. │ │ │ │ +

    source

    pub fn remove(&mut self, index: usize) -> Option<T>

    Removes and returns the element at index from the deque. │ │ │ │ Whichever end is closer to the removal point will be moved to make │ │ │ │ room, and all the affected elements will be moved to new positions. │ │ │ │ Returns None if index is out of bounds.

    │ │ │ │

    Element at index 0 is the front of the queue.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │ @@ -521,42 +521,42 @@
│ │ │ │  buf.push_back(1);
│ │ │ │  buf.push_back(2);
│ │ │ │  buf.push_back(3);
│ │ │ │  assert_eq!(buf, [1, 2, 3]);
│ │ │ │  
│ │ │ │  assert_eq!(buf.remove(1), Some(2));
│ │ │ │  assert_eq!(buf, [1, 3]);
    Run
    │ │ │ │ -
    1.4.0 · source

    pub fn split_off(&mut self, at: usize) -> Self
    where │ │ │ │ - A: Clone,

    Splits the deque into two at the given index.

    │ │ │ │ +
    1.4.0 · source

    pub fn split_off(&mut self, at: usize) -> Self
    where │ │ │ │ + A: Clone,

    Splits the deque into two at the given index.

    │ │ │ │

    Returns a newly allocated VecDeque. self contains elements [0, at), │ │ │ │ and the returned deque contains elements [at, len).

    │ │ │ │

    Note that the capacity of self does not change.

    │ │ │ │

    Element at index 0 is the front of the queue.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if at > len.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf: VecDeque<_> = [1, 2, 3].into();
│ │ │ │  let buf2 = buf.split_off(1);
│ │ │ │  assert_eq!(buf, [1]);
│ │ │ │  assert_eq!(buf2, [2, 3]);
    Run
    │ │ │ │ -
    1.4.0 · source

    pub fn append(&mut self, other: &mut Self)

    Moves all the elements of other into self, leaving other empty.

    │ │ │ │ +
    1.4.0 · source

    pub fn append(&mut self, other: &mut Self)

    Moves all the elements of other into self, leaving other empty.

    │ │ │ │
    §Panics
    │ │ │ │

    Panics if the new number of elements in self overflows a usize.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf: VecDeque<_> = [1, 2].into();
│ │ │ │  let mut buf2: VecDeque<_> = [3, 4].into();
│ │ │ │  buf.append(&mut buf2);
│ │ │ │  assert_eq!(buf, [1, 2, 3, 4]);
│ │ │ │  assert_eq!(buf2, []);
    Run
    │ │ │ │
    1.4.0 · source

    pub fn retain<F>(&mut self, f: F)
    where │ │ │ │ - F: FnMut(&T) -> bool,

    Retains only the elements specified by the predicate.

    │ │ │ │ + F: FnMut(&T) -> bool,

    Retains only the elements specified by the predicate.

    │ │ │ │

    In other words, remove all elements e for which f(&e) returns false. │ │ │ │ This method operates in place, visiting each element exactly once in the │ │ │ │ original order, and preserves the order of the retained elements.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::new();
│ │ │ │ @@ -572,15 +572,15 @@
│ │ │ │  buf.extend(1..6);
│ │ │ │  
│ │ │ │  let keep = [false, true, true, false, true];
│ │ │ │  let mut iter = keep.iter();
│ │ │ │  buf.retain(|_| *iter.next().unwrap());
│ │ │ │  assert_eq!(buf, [2, 3, 5]);
    Run
    │ │ │ │
    1.61.0 · source

    pub fn retain_mut<F>(&mut self, f: F)
    where │ │ │ │ - F: FnMut(&mut T) -> bool,

    Retains only the elements specified by the predicate.

    │ │ │ │ + F: FnMut(&mut T) -> bool,

    Retains only the elements specified by the predicate.

    │ │ │ │

    In other words, remove all elements e for which f(&e) returns false. │ │ │ │ This method operates in place, visiting each element exactly once in the │ │ │ │ original order, and preserves the order of the retained elements.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::new();
│ │ │ │ @@ -588,15 +588,15 @@
│ │ │ │  buf.retain_mut(|x| if *x % 2 == 0 {
│ │ │ │      *x += 1;
│ │ │ │      true
│ │ │ │  } else {
│ │ │ │      false
│ │ │ │  });
│ │ │ │  assert_eq!(buf, [3, 5]);
    Run
    │ │ │ │ -
    1.33.0 · source

    pub fn resize_with(&mut self, new_len: usize, generator: impl FnMut() -> T)

    Modifies the deque in-place so that len() is equal to new_len, │ │ │ │ +

    1.33.0 · source

    pub fn resize_with(&mut self, new_len: usize, generator: impl FnMut() -> T)

    Modifies the deque in-place so that len() is equal to new_len, │ │ │ │ either by removing excess elements from the back or by appending │ │ │ │ elements generated by calling generator to the back.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::new();
│ │ │ │  buf.push_back(5);
│ │ │ │ @@ -609,15 +609,15 @@
│ │ │ │  
│ │ │ │  buf.resize_with(2, || unreachable!());
│ │ │ │  assert_eq!(buf, [5, 10]);
│ │ │ │  
│ │ │ │  let mut state = 100;
│ │ │ │  buf.resize_with(5, || { state += 1; state });
│ │ │ │  assert_eq!(buf, [5, 10, 101, 102, 103]);
    Run
    │ │ │ │ -
    1.48.0 · source

    pub fn make_contiguous(&mut self) -> &mut [T]

    Rearranges the internal storage of this deque so it is one contiguous │ │ │ │ +

    1.48.0 · source

    pub fn make_contiguous(&mut self) -> &mut [T]

    Rearranges the internal storage of this deque so it is one contiguous │ │ │ │ slice, which is then returned.

    │ │ │ │

    This method does not allocate and does not change the order of the │ │ │ │ inserted elements. As it returns a mutable slice, this can be used to │ │ │ │ sort a deque.

    │ │ │ │

    Once the internal storage is contiguous, the as_slices and │ │ │ │ as_mut_slices methods will return the entire contents of the │ │ │ │ deque in a single slice.

    │ │ │ │ @@ -652,15 +652,15 @@ │ │ │ │ buf.make_contiguous(); │ │ │ │ if let (slice, &[]) = buf.as_slices() { │ │ │ │ // we can now be sure that `slice` contains all elements of the deque, │ │ │ │ // while still having immutable access to `buf`. │ │ │ │ assert_eq!(buf.len(), slice.len()); │ │ │ │ assert_eq!(slice, &[3, 2, 1] as &[_]); │ │ │ │ }    Run
    │ │ │ │ -
    1.36.0 · source

    pub fn rotate_left(&mut self, n: usize)

    Rotates the double-ended queue n places to the left.

    │ │ │ │ +
    1.36.0 · source

    pub fn rotate_left(&mut self, n: usize)

    Rotates the double-ended queue n places to the left.

    │ │ │ │

    Equivalently,

    │ │ │ │
      │ │ │ │
    • Rotates item n into the first position.
      • │ │ │ │
    • Pops the first n items and pushes them to the end.
      • │ │ │ │
    • Rotates len() - n places to the right.
      • │ │ │ │
    │ │ │ │
    §Panics
    │ │ │ │ @@ -677,15 +677,15 @@ │ │ │ │ assert_eq!(buf, [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]); │ │ │ │ │ │ │ │ for i in 1..10 { │ │ │ │ assert_eq!(i * 3 % 10, buf[0]); │ │ │ │ buf.rotate_left(3); │ │ │ │ } │ │ │ │ assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);    Run
    │ │ │ │ -
    1.36.0 · source

    pub fn rotate_right(&mut self, n: usize)

    Rotates the double-ended queue n places to the right.

    │ │ │ │ +
    1.36.0 · source

    pub fn rotate_right(&mut self, n: usize)

    Rotates the double-ended queue n places to the right.

    │ │ │ │

    Equivalently,

    │ │ │ │
      │ │ │ │
    • Rotates the first item into position n.
      • │ │ │ │
    • Pops the last n items and pushes them to the front.
      • │ │ │ │
    • Rotates len() - n places to the left.
      • │ │ │ │
    │ │ │ │
    §Panics
    │ │ │ │ @@ -702,22 +702,22 @@ │ │ │ │ assert_eq!(buf, [7, 8, 9, 0, 1, 2, 3, 4, 5, 6]); │ │ │ │ │ │ │ │ for i in 1..10 { │ │ │ │ assert_eq!(0, buf[i * 3 % 10]); │ │ │ │ buf.rotate_right(3); │ │ │ │ } │ │ │ │ assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);Run
    │ │ │ │ -

    Binary searches this VecDeque for a given element. │ │ │ │ +

    Binary searches this VecDeque for a given element. │ │ │ │ If the VecDeque is not sorted, the returned result is unspecified and │ │ │ │ meaningless.

    │ │ │ │ -

    If the value is found then Result::Ok is returned, containing the │ │ │ │ +

    If the value is found then Result::Ok is returned, containing the │ │ │ │ index of the matching element. If there are multiple matches, then any │ │ │ │ one of the matches could be returned. If the value is not found then │ │ │ │ -Result::Err is returned, containing the index where a matching │ │ │ │ +Result::Err is returned, containing the index where a matching │ │ │ │ element could be inserted while maintaining sorted order.

    │ │ │ │

    See also binary_search_by, binary_search_by_key, and partition_point.

    │ │ │ │
    §Examples
    │ │ │ │

    Looks up a series of four elements. The first is found, with a │ │ │ │ uniquely determined position; the second and third are not │ │ │ │ found; the fourth could match any position in [1, 4].

    │ │ │ │ │ │ │ │ @@ -737,26 +737,26 @@ │ │ │ │ │ │ │ │ let mut deque: VecDeque<_> = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into(); │ │ │ │ let num = 42; │ │ │ │ let idx = deque.partition_point(|&x| x < num); │ │ │ │ // The above is equivalent to `let idx = deque.binary_search(&num).unwrap_or_else(|x| x);` │ │ │ │ deque.insert(idx, num); │ │ │ │ assert_eq!(deque, &[0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);Run
    │ │ │ │ -
    1.54.0 · source

    pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
    where │ │ │ │ - F: FnMut(&'a T) -> Ordering,

    Binary searches this VecDeque with a comparator function.

    │ │ │ │ +
    1.54.0 · source

    pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
    where │ │ │ │ + F: FnMut(&'a T) -> Ordering,

    Binary searches this VecDeque with a comparator function.

    │ │ │ │

    The comparator function should return an order code that indicates │ │ │ │ whether its argument is Less, Equal or Greater the desired │ │ │ │ target. │ │ │ │ If the VecDeque is not sorted or if the comparator function does not │ │ │ │ implement an order consistent with the sort order of the underlying │ │ │ │ VecDeque, the returned result is unspecified and meaningless.

    │ │ │ │ -

    If the value is found then Result::Ok is returned, containing the │ │ │ │ +

    If the value is found then Result::Ok is returned, containing the │ │ │ │ index of the matching element. If there are multiple matches, then any │ │ │ │ one of the matches could be returned. If the value is not found then │ │ │ │ -Result::Err is returned, containing the index where a matching │ │ │ │ +Result::Err is returned, containing the index where a matching │ │ │ │ element could be inserted while maintaining sorted order.

    │ │ │ │

    See also binary_search, binary_search_by_key, and partition_point.

    │ │ │ │
    §Examples
    │ │ │ │

    Looks up a series of four elements. The first is found, with a │ │ │ │ uniquely determined position; the second and third are not │ │ │ │ found; the fourth could match any position in [1, 4].

    │ │ │ │ │ │ │ │ @@ -767,27 +767,27 @@ │ │ │ │ assert_eq!(deque.binary_search_by(|x| x.cmp(&13)), Ok(9)); │ │ │ │ assert_eq!(deque.binary_search_by(|x| x.cmp(&4)), Err(7)); │ │ │ │ assert_eq!(deque.binary_search_by(|x| x.cmp(&100)), Err(13)); │ │ │ │ let r = deque.binary_search_by(|x| x.cmp(&1)); │ │ │ │ assert!(matches!(r, Ok(1..=4)));Run
    │ │ │ │
    1.54.0 · source

    pub fn binary_search_by_key<'a, B, F>( │ │ │ │ &'a self, │ │ │ │ - b: &B, │ │ │ │ + b: &B, │ │ │ │ f: F │ │ │ │ -) -> Result<usize, usize>
    where │ │ │ │ - F: FnMut(&'a T) -> B, │ │ │ │ - B: Ord,

    Binary searches this VecDeque with a key extraction function.

    │ │ │ │ +) -> Result<usize, usize>
    where │ │ │ │ + F: FnMut(&'a T) -> B, │ │ │ │ + B: Ord,

    Binary searches this VecDeque with a key extraction function.

    │ │ │ │

    Assumes that the deque is sorted by the key, for instance with │ │ │ │ make_contiguous().sort_by_key() using the same key extraction function. │ │ │ │ If the deque is not sorted by the key, the returned result is │ │ │ │ unspecified and meaningless.

    │ │ │ │ -

    If the value is found then Result::Ok is returned, containing the │ │ │ │ +

    If the value is found then Result::Ok is returned, containing the │ │ │ │ index of the matching element. If there are multiple matches, then any │ │ │ │ one of the matches could be returned. If the value is not found then │ │ │ │ -Result::Err is returned, containing the index where a matching │ │ │ │ +Result::Err is returned, containing the index where a matching │ │ │ │ element could be inserted while maintaining sorted order.

    │ │ │ │

    See also binary_search, binary_search_by, and partition_point.

    │ │ │ │
    §Examples
    │ │ │ │

    Looks up a series of four elements in a slice of pairs sorted by │ │ │ │ their second elements. The first is found, with a uniquely │ │ │ │ determined position; the second and third are not found; the │ │ │ │ fourth could match any position in [1, 4].

    │ │ │ │ @@ -799,16 +799,16 @@ │ │ │ │ (1, 21), (2, 34), (4, 55)].into(); │ │ │ │ │ │ │ │ assert_eq!(deque.binary_search_by_key(&13, |&(a, b)| b), Ok(9)); │ │ │ │ assert_eq!(deque.binary_search_by_key(&4, |&(a, b)| b), Err(7)); │ │ │ │ assert_eq!(deque.binary_search_by_key(&100, |&(a, b)| b), Err(13)); │ │ │ │ let r = deque.binary_search_by_key(&1, |&(a, b)| b); │ │ │ │ assert!(matches!(r, Ok(1..=4)));Run
    │ │ │ │ -
    1.54.0 · source

    pub fn partition_point<P>(&self, pred: P) -> usize
    where │ │ │ │ - P: FnMut(&T) -> bool,

    Returns the index of the partition point according to the given predicate │ │ │ │ +

    1.54.0 · source

    pub fn partition_point<P>(&self, pred: P) -> usize
    where │ │ │ │ + P: FnMut(&T) -> bool,

    Returns the index of the partition point according to the given predicate │ │ │ │ (the index of the first element of the second partition).

    │ │ │ │

    The deque is assumed to be partitioned according to the given predicate. │ │ │ │ This means that all elements for which the predicate returns true are at the start of the deque │ │ │ │ and all elements for which the predicate returns false are at the end. │ │ │ │ For example, [7, 15, 3, 5, 4, 12, 6] is partitioned under the predicate x % 2 != 0 │ │ │ │ (all odd numbers are at the start, all even at the end).

    │ │ │ │

    If the deque is not partitioned, the returned result is unspecified and meaningless, │ │ │ │ @@ -829,15 +829,15 @@ │ │ │ │ 

    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut deque: VecDeque<_> = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into();
│ │ │ │  let num = 42;
│ │ │ │  let idx = deque.partition_point(|&x| x < num);
│ │ │ │  deque.insert(idx, num);
│ │ │ │  assert_eq!(deque, &[0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
    Run
    │ │ │ │ -
    source§

    impl<T: Clone, A: Allocator> VecDeque<T, A>

    1.16.0 · source

    pub fn resize(&mut self, new_len: usize, value: T)

    Modifies the deque in-place so that len() is equal to new_len, │ │ │ │ +

    source§

    impl<T: Clone, A: Allocator> VecDeque<T, A>

    1.16.0 · source

    pub fn resize(&mut self, new_len: usize, value: T)

    Modifies the deque in-place so that len() is equal to new_len, │ │ │ │ either by removing excess elements from the back or by appending clones of value │ │ │ │ to the back.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let mut buf = VecDeque::new();
│ │ │ │  buf.push_back(5);
│ │ │ │ @@ -846,27 +846,27 @@
│ │ │ │  assert_eq!(buf, [5, 10, 15]);
│ │ │ │  
│ │ │ │  buf.resize(2, 0);
│ │ │ │  assert_eq!(buf, [5, 10]);
│ │ │ │  
│ │ │ │  buf.resize(5, 20);
│ │ │ │  assert_eq!(buf, [5, 10, 20, 20, 20]);
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, other: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Debug, A: Allocator> Debug for VecDeque<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T> Default for VecDeque<T>

    source§

    fn default() -> VecDeque<T>

    Creates an empty deque.

    │ │ │ │ -
    source§

    impl<T, A: Allocator> Drop for VecDeque<T, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.2.0 · source§

    impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque<T, A>

    source§

    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: &'a T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl<T, A: Allocator> Extend<T> for VecDeque<T, A>

    source§

    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.56.0 · source§

    impl<T, const N: usize> From<[T; N]> for VecDeque<T>

    source§

    fn from(arr: [T; N]) -> Self

    Converts a [T; N] into a VecDeque<T>.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A>

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, other: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: Debug, A: Allocator> Debug for VecDeque<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T> Default for VecDeque<T>

    source§

    fn default() -> VecDeque<T>

    Creates an empty deque.

    │ │ │ │ +
    source§

    impl<T, A: Allocator> Drop for VecDeque<T, A>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.2.0 · source§

    impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque<T, A>

    source§

    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: &'a T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl<T, A: Allocator> Extend<T> for VecDeque<T, A>

    source§

    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, elem: T)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.56.0 · source§

    impl<T, const N: usize> From<[T; N]> for VecDeque<T>

    source§

    fn from(arr: [T; N]) -> Self

    Converts a [T; N] into a VecDeque<T>.

    │ │ │ │ │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  let deq1 = VecDeque::from([1, 2, 3, 4]);
│ │ │ │  let deq2: VecDeque<_> = [1, 2, 3, 4].into();
│ │ │ │  assert_eq!(deq1, deq2);
    Run
    │ │ │ │ -
    1.10.0 · source§

    impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A>

    source§

    fn from(other: Vec<T, A>) -> Self

    Turn a Vec<T> into a VecDeque<T>.

    │ │ │ │ +
    1.10.0 · source§

    impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A>

    source§

    fn from(other: Vec<T, A>) -> Self

    Turn a Vec<T> into a VecDeque<T>.

    │ │ │ │

    This conversion is guaranteed to run in O(1) time │ │ │ │ and to not re-allocate the Vec’s buffer or allocate │ │ │ │ any additional memory.

    │ │ │ │ -
    1.10.0 · source§

    impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A>

    source§

    fn from(other: VecDeque<T, A>) -> Self

    Turn a VecDeque<T> into a Vec<T>.

    │ │ │ │ +
    1.10.0 · source§

    impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A>

    source§

    fn from(other: VecDeque<T, A>) -> Self

    Turn a VecDeque<T> into a Vec<T>.

    │ │ │ │

    This never needs to re-allocate, but does need to do O(n) data movement if │ │ │ │ the circular buffer doesn’t happen to be at the beginning of the allocation.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  // This one is *O*(1).
│ │ │ │  let deque: VecDeque<_> = (1..5).collect();
│ │ │ │ @@ -879,59 +879,59 @@
│ │ │ │  let mut deque: VecDeque<_> = (1..5).collect();
│ │ │ │  deque.push_front(9);
│ │ │ │  deque.push_front(8);
│ │ │ │  let ptr = deque.as_slices().1.as_ptr();
│ │ │ │  let vec = Vec::from(deque);
│ │ │ │  assert_eq!(vec, [8, 9, 1, 2, 3, 4]);
│ │ │ │  assert_eq!(vec.as_ptr(), ptr);
    Run
    │ │ │ │ -
    source§

    impl<T> FromIterator<T> for VecDeque<T>

    source§

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T>

    Creates a value from an iterator. Read more
    source§

    impl<T: Hash, A: Allocator> Hash for VecDeque<T, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ - H: Hasher, │ │ │ │ - Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<T, A: Allocator> Index<usize> for VecDeque<T, A>

    §

    type Output = T

    The returned type after indexing.
    source§

    fn index(&self, index: usize) -> &T

    Performs the indexing (container[index]) operation. Read more
    source§

    impl<T, A: Allocator> IndexMut<usize> for VecDeque<T, A>

    source§

    fn index_mut(&mut self, index: usize) -> &mut T

    Performs the mutable indexing (container[index]) operation. Read more
    source§

    impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque<T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    §

    type IntoIter = Iter<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Iter<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque<T, A>

    §

    type Item = &'a mut T

    The type of the elements being iterated over.
    §

    type IntoIter = IterMut<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> IterMut<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<T, A: Allocator> IntoIterator for VecDeque<T, A>

    source§

    fn into_iter(self) -> IntoIter<T, A> ⓘ

    Consumes the deque into a front-to-back iterator yielding elements by │ │ │ │ +

    source§

    impl<T> FromIterator<T> for VecDeque<T>

    source§

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T>

    Creates a value from an iterator. Read more
    source§

    impl<T: Hash, A: Allocator> Hash for VecDeque<T, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ + H: Hasher, │ │ │ │ + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<T, A: Allocator> Index<usize> for VecDeque<T, A>

    §

    type Output = T

    The returned type after indexing.
    source§

    fn index(&self, index: usize) -> &T

    Performs the indexing (container[index]) operation. Read more
    source§

    impl<T, A: Allocator> IndexMut<usize> for VecDeque<T, A>

    source§

    fn index_mut(&mut self, index: usize) -> &mut T

    Performs the mutable indexing (container[index]) operation. Read more
    source§

    impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque<T, A>

    §

    type Item = &'a T

    The type of the elements being iterated over.
    §

    type IntoIter = Iter<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Iter<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque<T, A>

    §

    type Item = &'a mut T

    The type of the elements being iterated over.
    §

    type IntoIter = IterMut<'a, T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> IterMut<'a, T> ⓘ

    Creates an iterator from a value. Read more
    source§

    impl<T, A: Allocator> IntoIterator for VecDeque<T, A>

    source§

    fn into_iter(self) -> IntoIter<T, A> ⓘ

    Consumes the deque into a front-to-back iterator yielding elements by │ │ │ │ value.

    │ │ │ │ -
    §

    type Item = T

    The type of the elements being iterated over.
    §

    type IntoIter = IntoIter<T, A>

    Which kind of iterator are we turning this into?
    source§

    impl<T: Ord, A: Allocator> Ord for VecDeque<T, A>

    source§

    fn cmp(&self, other: &Self) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ - Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    1.17.0 · source§

    impl<T, U, A: Allocator> PartialEq<&[U]> for VecDeque<T, A>
    where │ │ │ │ - T: PartialEq<U>,

    source§

    fn eq(&self, other: &&[U]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    1.17.0 · source§

    impl<T, U, A: Allocator, const N: usize> PartialEq<&[U; N]> for VecDeque<T, A>
    where │ │ │ │ - T: PartialEq<U>,

    source§

    fn eq(&self, other: &&[U; N]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    1.17.0 · source§

    impl<T, U, A: Allocator> PartialEq<&mut [U]> for VecDeque<T, A>
    where │ │ │ │ - T: PartialEq<U>,

    source§

    fn eq(&self, other: &&mut [U]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    1.17.0 · source§

    impl<T, U, A: Allocator, const N: usize> PartialEq<&mut [U; N]> for VecDeque<T, A>
    where │ │ │ │ - T: PartialEq<U>,

    source§

    fn eq(&self, other: &&mut [U; N]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    1.17.0 · source§

    impl<T, U, A: Allocator, const N: usize> PartialEq<[U; N]> for VecDeque<T, A>
    where │ │ │ │ - T: PartialEq<U>,

    source§

    fn eq(&self, other: &[U; N]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    1.17.0 · source§

    impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for VecDeque<T, A>
    where │ │ │ │ - T: PartialEq<U>,

    source§

    fn eq(&self, other: &Vec<U, A>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<T: PartialEq, A: Allocator> PartialEq for VecDeque<T, A>

    source§

    fn eq(&self, other: &Self) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl<T: PartialOrd, A: Allocator> PartialOrd for VecDeque<T, A>

    source§

    fn partial_cmp(&self, other: &Self) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ -operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ -operator. Read more
    source§

    impl<T: Eq, A: Allocator> Eq for VecDeque<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for VecDeque<T, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<T, A> RefUnwindSafe for VecDeque<T, A>
    where │ │ │ │ - A: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<T, A> Send for VecDeque<T, A>
    where │ │ │ │ - A: Send, │ │ │ │ - T: Send,

    §

    impl<T, A> Sync for VecDeque<T, A>
    where │ │ │ │ - A: Sync, │ │ │ │ - T: Sync,

    §

    impl<T, A> Unpin for VecDeque<T, A>
    where │ │ │ │ - A: Unpin, │ │ │ │ - T: Unpin,

    §

    impl<T, A> UnwindSafe for VecDeque<T, A>
    where │ │ │ │ - A: UnwindSafe, │ │ │ │ - T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +
    §

    type Item = T

    The type of the elements being iterated over.
    §

    type IntoIter = IntoIter<T, A>

    Which kind of iterator are we turning this into?
    source§

    impl<T: Ord, A: Allocator> Ord for VecDeque<T, A>

    source§

    fn cmp(&self, other: &Self) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ + Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    1.17.0 · source§

    impl<T, U, A: Allocator> PartialEq<&[U]> for VecDeque<T, A>
    where │ │ │ │ + T: PartialEq<U>,

    source§

    fn eq(&self, other: &&[U]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    1.17.0 · source§

    impl<T, U, A: Allocator, const N: usize> PartialEq<&[U; N]> for VecDeque<T, A>
    where │ │ │ │ + T: PartialEq<U>,

    source§

    fn eq(&self, other: &&[U; N]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    1.17.0 · source§

    impl<T, U, A: Allocator> PartialEq<&mut [U]> for VecDeque<T, A>
    where │ │ │ │ + T: PartialEq<U>,

    source§

    fn eq(&self, other: &&mut [U]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    1.17.0 · source§

    impl<T, U, A: Allocator, const N: usize> PartialEq<&mut [U; N]> for VecDeque<T, A>
    where │ │ │ │ + T: PartialEq<U>,

    source§

    fn eq(&self, other: &&mut [U; N]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    1.17.0 · source§

    impl<T, U, A: Allocator, const N: usize> PartialEq<[U; N]> for VecDeque<T, A>
    where │ │ │ │ + T: PartialEq<U>,

    source§

    fn eq(&self, other: &[U; N]) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    1.17.0 · source§

    impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for VecDeque<T, A>
    where │ │ │ │ + T: PartialEq<U>,

    source§

    fn eq(&self, other: &Vec<U, A>) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<T: PartialEq, A: Allocator> PartialEq for VecDeque<T, A>

    source§

    fn eq(&self, other: &Self) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl<T: PartialOrd, A: Allocator> PartialOrd for VecDeque<T, A>

    source§

    fn partial_cmp(&self, other: &Self) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ +operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ +operator. Read more
    source§

    impl<T: Eq, A: Allocator> Eq for VecDeque<T, A>

    Auto Trait Implementations§

    §

    impl<T, A> Freeze for VecDeque<T, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<T, A> RefUnwindSafe for VecDeque<T, A>
    where │ │ │ │ + A: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<T, A> Send for VecDeque<T, A>
    where │ │ │ │ + A: Send, │ │ │ │ + T: Send,

    §

    impl<T, A> Sync for VecDeque<T, A>
    where │ │ │ │ + A: Sync, │ │ │ │ + T: Sync,

    §

    impl<T, A> Unpin for VecDeque<T, A>
    where │ │ │ │ + A: Unpin, │ │ │ │ + T: Unpin,

    §

    impl<T, A> UnwindSafe for VecDeque<T, A>
    where │ │ │ │ + A: UnwindSafe, │ │ │ │ + T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.CString.html │ │ │ │ @@ -1,45 +1,45 @@ │ │ │ │ CString in alloc::ffi::c_str - Rust
    │ │ │ │

    Struct alloc::ffi::c_str::CString

    1.64.0 · source · 
    pub struct CString { /* private fields */ }
    Expand description

    A type representing an owned, C-compatible, nul-terminated string with no nul bytes in the │ │ │ │ middle.

    │ │ │ │

    This type serves the purpose of being able to safely generate a │ │ │ │ C-compatible string from a Rust byte slice or vector. An instance of this │ │ │ │ type is a static guarantee that the underlying bytes contain no interior 0 │ │ │ │ bytes (“nul characters”) and that the final byte is 0 (“nul terminator”).

    │ │ │ │ -

    CString is to &CStr as String is to &str: the former │ │ │ │ +

    CString is to &CStr as String is to &str: the former │ │ │ │ in each pair are owned strings; the latter are borrowed │ │ │ │ references.

    │ │ │ │

    §Creating a CString

    │ │ │ │

    A CString is created from either a byte slice or a byte vector, │ │ │ │ -or anything that implements Into<Vec<u8>> (for │ │ │ │ +or anything that implements Into<Vec<u8>> (for │ │ │ │ example, you can build a CString straight out of a String or │ │ │ │ -a &str, since both implement that trait).

    │ │ │ │ -

    The CString::new method will actually check that the provided &[u8] │ │ │ │ +a &str, since both implement that trait).

    │ │ │ │ +

    The CString::new method will actually check that the provided &[u8] │ │ │ │ does not have 0 bytes in the middle, and return an error if it │ │ │ │ finds one.

    │ │ │ │

    §Extracting a raw pointer to the whole C string

    │ │ │ │ -

    CString implements an as_ptr method through the Deref │ │ │ │ +

    CString implements an as_ptr method through the Deref │ │ │ │ trait. This method will give you a *const c_char which you can │ │ │ │ feed directly to extern functions that expect a nul-terminated │ │ │ │ -string, like C’s strdup(). Notice that as_ptr returns a │ │ │ │ +string, like C’s strdup(). Notice that as_ptr returns a │ │ │ │ read-only pointer; if the C code writes to it, that causes │ │ │ │ undefined behavior.

    │ │ │ │

    §Extracting a slice of the whole C string

    │ │ │ │ -

    Alternatively, you can obtain a &[u8] slice from a │ │ │ │ +

    Alternatively, you can obtain a &[u8] slice from a │ │ │ │ CString with the CString::as_bytes method. Slices produced in this │ │ │ │ way do not contain the trailing nul terminator. This is useful │ │ │ │ when you will be calling an extern function that takes a *const u8 argument which is not necessarily nul-terminated, plus another │ │ │ │ argument with the length of the string — like C’s strndup(). │ │ │ │ You can of course get the slice’s length with its │ │ │ │ -len method.

    │ │ │ │ -

    If you need a &[u8] slice with the nul terminator, you │ │ │ │ +len method.

    │ │ │ │ +

    If you need a &[u8] slice with the nul terminator, you │ │ │ │ can use CString::as_bytes_with_nul instead.

    │ │ │ │

    Once you have the kind of slice you need (with or without a nul │ │ │ │ terminator), you can call the slice’s own │ │ │ │ -as_ptr method to get a read-only raw pointer to pass to │ │ │ │ +as_ptr method to get a read-only raw pointer to pass to │ │ │ │ extern functions. See the documentation for that function for a │ │ │ │ discussion on ensuring the lifetime of the raw pointer.

    │ │ │ │

    §Examples

    │ │ │ │
    ⓘ
    use std::ffi::CString;
│ │ │ │  use std::os::raw::c_char;
│ │ │ │  
│ │ │ │  extern "C" {
│ │ │ │ @@ -57,15 +57,15 @@
│ │ │ │  (a sequence of non-nul bytes terminated by a single nul byte); the
│ │ │ │  primary use case for these kinds of strings is interoperating with C-like
│ │ │ │  code. Often you will need to transfer ownership to/from that external
│ │ │ │  code. It is strongly recommended that you thoroughly read through the
│ │ │ │  documentation of CString before use, as improper ownership management
│ │ │ │  of CString instances can lead to invalid memory accesses, memory leaks,
│ │ │ │  and other memory errors.
    
│ │ │ │ -

    Implementations§

    source§

    impl CString

    1.0.0 · source

    pub fn new<T: Into<Vec<u8>>>(t: T) -> Result<CString, NulError>

    Creates a new C-compatible string from a container of bytes.

    │ │ │ │ +

    Implementations§

    source§

    impl CString

    1.0.0 · source

    pub fn new<T: Into<Vec<u8>>>(t: T) -> Result<CString, NulError>

    Creates a new C-compatible string from a container of bytes.

    │ │ │ │

    This function will consume the provided data and use the │ │ │ │ underlying bytes to construct a new string, ensuring that │ │ │ │ there is a trailing 0 byte. This trailing 0 byte will be │ │ │ │ appended by this function; the provided data should not │ │ │ │ contain any 0 bytes in it.

    │ │ │ │
    §Examples
    │ │ │ │
    ⓘ
    use std::ffi::CString;
│ │ │ │ @@ -77,43 +77,43 @@
│ │ │ │  unsafe {
│ │ │ │      puts(to_print.as_ptr());
│ │ │ │  }
    Run
    │ │ │ │
    §Errors
    │ │ │ │

    This function will return an error if the supplied bytes contain an │ │ │ │ internal 0 byte. The NulError returned will contain the bytes as well as │ │ │ │ the position of the nul byte.

    │ │ │ │ -
    1.0.0 · source

    pub unsafe fn from_vec_unchecked(v: Vec<u8>) -> Self

    Creates a C-compatible string by consuming a byte vector, │ │ │ │ +

    1.0.0 · source

    pub unsafe fn from_vec_unchecked(v: Vec<u8>) -> Self

    Creates a C-compatible string by consuming a byte vector, │ │ │ │ without checking for interior 0 bytes.

    │ │ │ │

    Trailing 0 byte will be appended by this function.

    │ │ │ │

    This method is equivalent to CString::new except that no runtime │ │ │ │ assertion is made that v contains no 0 bytes, and it requires an │ │ │ │ actual byte vector, not anything that can be converted to one with Into.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let raw = b"foo".to_vec();
│ │ │ │  unsafe {
│ │ │ │      let c_string = CString::from_vec_unchecked(raw);
│ │ │ │  }
    Run
    │ │ │ │ -
    1.4.0 · source

    pub unsafe fn from_raw(ptr: *mut c_char) -> CString

    Retakes ownership of a CString that was transferred to C via │ │ │ │ +

    1.4.0 · source

    pub unsafe fn from_raw(ptr: *mut c_char) -> CString

    Retakes ownership of a CString that was transferred to C via │ │ │ │ CString::into_raw.

    │ │ │ │

    Additionally, the length of the string will be recalculated from the pointer.

    │ │ │ │
    §Safety
    │ │ │ │

    This should only ever be called with a pointer that was earlier │ │ │ │ obtained by calling CString::into_raw. Other usage (e.g., trying to take │ │ │ │ ownership of a string that was allocated by foreign code) is likely to lead │ │ │ │ to undefined behavior or allocator corruption.

    │ │ │ │

    It should be noted that the length isn’t just “recomputed,” but that │ │ │ │ the recomputed length must match the original length from the │ │ │ │ CString::into_raw call. This means the CString::into_raw/from_raw │ │ │ │ methods should not be used when passing the string to C functions that can │ │ │ │ modify the string’s length.

    │ │ │ │
    │ │ │ │

    Note: If you need to borrow a string that was allocated by │ │ │ │ -foreign code, use CStr. If you need to take ownership of │ │ │ │ +foreign code, use CStr. If you need to take ownership of │ │ │ │ a string that was allocated by foreign code, you will need to │ │ │ │ make your own provisions for freeing it appropriately, likely │ │ │ │ with the foreign code’s API to do that.

    │ │ │ │
    │ │ │ │
    §Examples
    │ │ │ │

    Creates a CString, pass ownership to an extern function (via raw pointer), then retake │ │ │ │ ownership with from_raw:

    │ │ │ │ @@ -127,15 +127,15 @@ │ │ │ │ │ │ │ │ let c_string = CString::new("Hello!").expect("CString::new failed"); │ │ │ │ let raw = c_string.into_raw(); │ │ │ │ unsafe { │ │ │ │ some_extern_function(raw); │ │ │ │ let c_string = CString::from_raw(raw); │ │ │ │ }    Run
    │ │ │ │ -
    1.4.0 · source

    pub fn into_raw(self) -> *mut c_char

    Consumes the CString and transfers ownership of the string to a C caller.

    │ │ │ │ +
    1.4.0 · source

    pub fn into_raw(self) -> *mut c_char

    Consumes the CString and transfers ownership of the string to a C caller.

    │ │ │ │

    The pointer which this function returns must be returned to Rust and reconstituted using │ │ │ │ CString::from_raw to be properly deallocated. Specifically, one │ │ │ │ should not use the standard C free() function to deallocate │ │ │ │ this string.

    │ │ │ │

    Failure to call CString::from_raw will lead to a memory leak.

    │ │ │ │

    The C side must not modify the length of the string (by writing a │ │ │ │ nul byte somewhere inside the string or removing the final one) before │ │ │ │ @@ -153,92 +153,92 @@ │ │ │ │ assert_eq!(b'o', *ptr.add(1) as u8); │ │ │ │ assert_eq!(b'o', *ptr.add(2) as u8); │ │ │ │ assert_eq!(b'\0', *ptr.add(3) as u8); │ │ │ │ │ │ │ │ // retake pointer to free memory │ │ │ │ let _ = CString::from_raw(ptr); │ │ │ │ }Run

    │ │ │ │ -
    1.7.0 · source

    pub fn into_string(self) -> Result<String, IntoStringError>

    Converts the CString into a String if it contains valid UTF-8 data.

    │ │ │ │ +
    1.7.0 · source

    pub fn into_string(self) -> Result<String, IntoStringError>

    Converts the CString into a String if it contains valid UTF-8 data.

    │ │ │ │

    On failure, ownership of the original CString is returned.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let valid_utf8 = vec![b'f', b'o', b'o'];
│ │ │ │  let cstring = CString::new(valid_utf8).expect("CString::new failed");
│ │ │ │  assert_eq!(cstring.into_string().expect("into_string() call failed"), "foo");
│ │ │ │  
│ │ │ │  let invalid_utf8 = vec![b'f', 0xff, b'o', b'o'];
│ │ │ │  let cstring = CString::new(invalid_utf8).expect("CString::new failed");
│ │ │ │  let err = cstring.into_string().err().expect("into_string().err() failed");
│ │ │ │  assert_eq!(err.utf8_error().valid_up_to(), 1);
    Run
    │ │ │ │ -
    1.7.0 · source

    pub fn into_bytes(self) -> Vec<u8>

    Consumes the CString and returns the underlying byte buffer.

    │ │ │ │ +
    1.7.0 · source

    pub fn into_bytes(self) -> Vec<u8>

    Consumes the CString and returns the underlying byte buffer.

    │ │ │ │

    The returned buffer does not contain the trailing nul │ │ │ │ terminator, and it is guaranteed to not have any interior nul │ │ │ │ bytes.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let c_string = CString::new("foo").expect("CString::new failed");
│ │ │ │  let bytes = c_string.into_bytes();
│ │ │ │  assert_eq!(bytes, vec![b'f', b'o', b'o']);
    Run
    │ │ │ │ -
    1.7.0 · source

    pub fn into_bytes_with_nul(self) -> Vec<u8>

    Equivalent to CString::into_bytes() except that the │ │ │ │ +

    1.7.0 · source

    pub fn into_bytes_with_nul(self) -> Vec<u8>

    Equivalent to CString::into_bytes() except that the │ │ │ │ returned vector includes the trailing nul terminator.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let c_string = CString::new("foo").expect("CString::new failed");
│ │ │ │  let bytes = c_string.into_bytes_with_nul();
│ │ │ │  assert_eq!(bytes, vec![b'f', b'o', b'o', b'\0']);
    Run
    │ │ │ │ -
    1.0.0 · source

    pub fn as_bytes(&self) -> &[u8]

    Returns the contents of this CString as a slice of bytes.

    │ │ │ │ +
    1.0.0 · source

    pub fn as_bytes(&self) -> &[u8]

    Returns the contents of this CString as a slice of bytes.

    │ │ │ │

    The returned slice does not contain the trailing nul │ │ │ │ terminator, and it is guaranteed to not have any interior nul │ │ │ │ bytes. If you need the nul terminator, use │ │ │ │ CString::as_bytes_with_nul instead.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let c_string = CString::new("foo").expect("CString::new failed");
│ │ │ │  let bytes = c_string.as_bytes();
│ │ │ │  assert_eq!(bytes, &[b'f', b'o', b'o']);
    Run
    │ │ │ │ -
    1.0.0 · source

    pub fn as_bytes_with_nul(&self) -> &[u8]

    Equivalent to CString::as_bytes() except that the │ │ │ │ +

    1.0.0 · source

    pub fn as_bytes_with_nul(&self) -> &[u8]

    Equivalent to CString::as_bytes() except that the │ │ │ │ returned slice includes the trailing nul terminator.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let c_string = CString::new("foo").expect("CString::new failed");
│ │ │ │  let bytes = c_string.as_bytes_with_nul();
│ │ │ │  assert_eq!(bytes, &[b'f', b'o', b'o', b'\0']);
    Run
    │ │ │ │ -
    1.20.0 · source

    pub fn as_c_str(&self) -> &CStr

    Extracts a CStr slice containing the entire string.

    │ │ │ │ +
    1.20.0 · source

    pub fn as_c_str(&self) -> &CStr

    Extracts a CStr slice containing the entire string.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::{CString, CStr};
│ │ │ │  
│ │ │ │  let c_string = CString::new(b"foo".to_vec()).expect("CString::new failed");
│ │ │ │  let cstr = c_string.as_c_str();
│ │ │ │  assert_eq!(cstr,
│ │ │ │             CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed"));
    Run
    │ │ │ │ -
    1.20.0 · source

    pub fn into_boxed_c_str(self) -> Box<CStr>

    Converts this CString into a boxed CStr.

    │ │ │ │ +
    1.20.0 · source

    pub fn into_boxed_c_str(self) -> Box<CStr>

    Converts this CString into a boxed CStr.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::{CString, CStr};
│ │ │ │  
│ │ │ │  let c_string = CString::new(b"foo".to_vec()).expect("CString::new failed");
│ │ │ │  let boxed = c_string.into_boxed_c_str();
│ │ │ │  assert_eq!(&*boxed,
│ │ │ │             CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed"));
    Run
    │ │ │ │ -
    1.58.0 · source

    pub unsafe fn from_vec_with_nul_unchecked(v: Vec<u8>) -> Self

    Converts a Vec<u8> to a CString without checking the │ │ │ │ +

    1.58.0 · source

    pub unsafe fn from_vec_with_nul_unchecked(v: Vec<u8>) -> Self

    Converts a Vec<u8> to a CString without checking the │ │ │ │ invariants on the given Vec.

    │ │ │ │
    §Safety
    │ │ │ │

    The given Vec must have one nul byte as its last element. │ │ │ │ This means it cannot be empty nor have any other nul byte anywhere else.

    │ │ │ │
    §Example
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  assert_eq!(
│ │ │ │      unsafe { CString::from_vec_with_nul_unchecked(b"abc\0".to_vec()) },
│ │ │ │      unsafe { CString::from_vec_unchecked(b"abc".to_vec()) }
│ │ │ │  );
    Run
    │ │ │ │ -
    1.58.0 · source

    pub fn from_vec_with_nul(v: Vec<u8>) -> Result<Self, FromVecWithNulError>

    Attempts to converts a Vec<u8> to a CString.

    │ │ │ │ +
    1.58.0 · source

    pub fn from_vec_with_nul(v: Vec<u8>) -> Result<Self, FromVecWithNulError>

    Attempts to converts a Vec<u8> to a CString.

    │ │ │ │

    Runtime checks are present to ensure there is only one nul byte in the │ │ │ │ Vec, its last element.

    │ │ │ │
    §Errors
    │ │ │ │

    If a nul byte is present and not the last element or no nul bytes │ │ │ │ is present, an error will be returned.

    │ │ │ │
    §Examples
    │ │ │ │

    A successful conversion will produce the same result as CString::new │ │ │ │ @@ -253,21 +253,21 @@ │ │ │ │

    An incorrectly formatted Vec will produce an error.

    │ │ │ │ │ │ │ │ 
    use std::ffi::{CString, FromVecWithNulError};
│ │ │ │  // Interior nul byte
│ │ │ │  let _: FromVecWithNulError = CString::from_vec_with_nul(b"a\0bc".to_vec()).unwrap_err();
│ │ │ │  // No nul byte
│ │ │ │  let _: FromVecWithNulError = CString::from_vec_with_nul(b"abc".to_vec()).unwrap_err();
    Run
    │ │ │ │ -

    Methods from Deref<Target = CStr>§

    1.4.0 · source

    pub fn to_string_lossy(&self) -> Cow<'_, str>

    Converts a CStr into a Cow<str>.

    │ │ │ │ +

    Methods from Deref<Target = CStr>§

    1.4.0 · source

    pub fn to_string_lossy(&self) -> Cow<'_, str>

    Converts a CStr into a Cow<str>.

    │ │ │ │

    If the contents of the CStr are valid UTF-8 data, this │ │ │ │ -function will return a Cow::Borrowed(&str) │ │ │ │ -with the corresponding &str slice. Otherwise, it will │ │ │ │ +function will return a Cow::Borrowed(&str) │ │ │ │ +with the corresponding &str slice. Otherwise, it will │ │ │ │ replace any invalid UTF-8 sequences with │ │ │ │ -U+FFFD REPLACEMENT CHARACTER and return a │ │ │ │ -Cow::Owned(&str) with the result.

    │ │ │ │ +U+FFFD REPLACEMENT CHARACTER and return a │ │ │ │ +Cow::Owned(&str) with the result.

    │ │ │ │
    §Examples
    │ │ │ │

    Calling to_string_lossy on a CStr containing valid UTF-8:

    │ │ │ │ │ │ │ │ 
    use std::borrow::Cow;
│ │ │ │  use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"Hello World\0")
│ │ │ │ @@ -280,20 +280,20 @@
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"Hello \xF0\x90\x80World\0")
│ │ │ │                   .expect("CStr::from_bytes_with_nul failed");
│ │ │ │  assert_eq!(
│ │ │ │      cstr.to_string_lossy(),
│ │ │ │      Cow::Owned(String::from("Hello �World")) as Cow<'_, str>
│ │ │ │  );
    Run
    │ │ │ │ -
    1.0.0 · source

    pub fn as_ptr(&self) -> *const i8

    Returns the inner pointer to this C string.

    │ │ │ │ +
    1.0.0 · source

    pub fn as_ptr(&self) -> *const i8

    Returns the inner pointer to this C string.

    │ │ │ │

    The returned pointer will be valid for as long as self is, and points │ │ │ │ to a contiguous region of memory terminated with a 0 byte to represent │ │ │ │ the end of the string.

    │ │ │ │

    The type of the returned pointer is │ │ │ │ -*const c_char, and whether it’s │ │ │ │ +*const c_char, and whether it’s │ │ │ │ an alias for *const i8 or *const u8 is platform-specific.

    │ │ │ │

    WARNING

    │ │ │ │

    The returned pointer is read-only; writing to it (including passing it │ │ │ │ to C code that writes to it) causes undefined behavior.

    │ │ │ │

    It is your responsibility to make sure that the underlying memory is not │ │ │ │ freed too early. For example, the following code will cause undefined │ │ │ │ behavior when ptr is used inside the unsafe block:

    │ │ │ │ @@ -318,15 +318,15 @@ │ │ │ │ let ptr = hello.as_ptr(); │ │ │ │ unsafe { │ │ │ │ // `ptr` is valid because `hello` is in scope │ │ │ │ *ptr; │ │ │ │ }Run
    │ │ │ │

    This way, the lifetime of the CString in hello encompasses │ │ │ │ the lifetime of ptr and the unsafe block.

    │ │ │ │ -
    source

    pub fn count_bytes(&self) -> usize

    🔬This is a nightly-only experimental API. (cstr_count_bytes #114441)

    Returns the length of self. Like C’s strlen, this does not include the nul terminator.

    │ │ │ │ +
    source

    pub fn count_bytes(&self) -> usize

    🔬This is a nightly-only experimental API. (cstr_count_bytes #114441)

    Returns the length of self. Like C’s strlen, this does not include the nul terminator.

    │ │ │ │
    │ │ │ │

    Note: This method is currently implemented as a constant-time │ │ │ │ cast, but it is planned to alter its definition in the future to │ │ │ │ perform the length calculation whenever this method is called.

    │ │ │ │
    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(cstr_count_bytes)]
│ │ │ │ @@ -334,98 +334,98 @@
│ │ │ │  use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0").unwrap();
│ │ │ │  assert_eq!(cstr.count_bytes(), 3);
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"\0").unwrap();
│ │ │ │  assert_eq!(cstr.count_bytes(), 0);
    Run
    │ │ │ │ -
    1.71.0 · source

    pub fn is_empty(&self) -> bool

    Returns true if self.to_bytes() has a length of 0.

    │ │ │ │ +
    1.71.0 · source

    pub fn is_empty(&self) -> bool

    Returns true if self.to_bytes() has a length of 0.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0")?;
│ │ │ │  assert!(!cstr.is_empty());
│ │ │ │  
│ │ │ │  let empty_cstr = CStr::from_bytes_with_nul(b"\0")?;
│ │ │ │  assert!(empty_cstr.is_empty());
    Run
    │ │ │ │ -
    1.0.0 · source

    pub fn to_bytes(&self) -> &[u8]

    Converts this C string to a byte slice.

    │ │ │ │ +
    1.0.0 · source

    pub fn to_bytes(&self) -> &[u8]

    Converts this C string to a byte slice.

    │ │ │ │

    The returned slice will not contain the trailing nul terminator that this C │ │ │ │ string has.

    │ │ │ │
    │ │ │ │

    Note: This method is currently implemented as a constant-time │ │ │ │ cast, but it is planned to alter its definition in the future to │ │ │ │ perform the length calculation whenever this method is called.

    │ │ │ │
    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
│ │ │ │  assert_eq!(cstr.to_bytes(), b"foo");
    Run
    │ │ │ │ -
    1.0.0 · source

    pub fn to_bytes_with_nul(&self) -> &[u8]

    Converts this C string to a byte slice containing the trailing 0 byte.

    │ │ │ │ -

    This function is the equivalent of CStr::to_bytes except that it │ │ │ │ +

    1.0.0 · source

    pub fn to_bytes_with_nul(&self) -> &[u8]

    Converts this C string to a byte slice containing the trailing 0 byte.

    │ │ │ │ +

    This function is the equivalent of CStr::to_bytes except that it │ │ │ │ will retain the trailing nul terminator instead of chopping it off.

    │ │ │ │
    │ │ │ │

    Note: This method is currently implemented as a 0-cost cast, but │ │ │ │ it is planned to alter its definition in the future to perform the │ │ │ │ length calculation whenever this method is called.

    │ │ │ │
    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
│ │ │ │  assert_eq!(cstr.to_bytes_with_nul(), b"foo\0");
    Run
    │ │ │ │ -
    source

    pub fn bytes(&self) -> Bytes<'_>

    🔬This is a nightly-only experimental API. (cstr_bytes #112115)

    Iterates over the bytes in this C string.

    │ │ │ │ +
    source

    pub fn bytes(&self) -> Bytes<'_>

    🔬This is a nightly-only experimental API. (cstr_bytes #112115)

    Iterates over the bytes in this C string.

    │ │ │ │

    The returned iterator will not contain the trailing nul terminator │ │ │ │ that this C string has.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(cstr_bytes)]
│ │ │ │  use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
│ │ │ │  assert!(cstr.bytes().eq(*b"foo"));
    Run
    │ │ │ │ -
    1.4.0 · source

    pub fn to_str(&self) -> Result<&str, Utf8Error>

    Yields a &str slice if the CStr contains valid UTF-8.

    │ │ │ │ +
    1.4.0 · source

    pub fn to_str(&self) -> Result<&str, Utf8Error>

    Yields a &str slice if the CStr contains valid UTF-8.

    │ │ │ │

    If the contents of the CStr are valid UTF-8 data, this │ │ │ │ -function will return the corresponding &str slice. Otherwise, │ │ │ │ +function will return the corresponding &str slice. Otherwise, │ │ │ │ it will return an error with details of where UTF-8 validation failed.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
│ │ │ │  assert_eq!(cstr.to_str(), Ok("foo"));
    Run
    │ │ │ │ -

    Trait Implementations§

    1.7.0 · source§

    impl AsRef<CStr> for CString

    source§

    fn as_ref(&self) -> &CStr

    Converts this type into a shared reference of the (usually inferred) input type.
    1.3.0 · source§

    impl Borrow<CStr> for CString

    source§

    fn borrow(&self) -> &CStr

    Immutably borrows from an owned value. Read more
    source§

    impl Clone for CString

    source§

    fn clone(&self) -> CString

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.0.0 · source§

    impl Debug for CString

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.10.0 · source§

    impl Default for CString

    source§

    fn default() -> CString

    Creates an empty CString.

    │ │ │ │ -
    1.0.0 · source§

    impl Deref for CString

    §

    type Target = CStr

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &CStr

    Dereferences the value.
    1.13.0 · source§

    impl Drop for CString

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.7.0 · source§

    impl From<&CStr> for CString

    source§

    fn from(s: &CStr) -> CString

    Converts a &CStr into a CString │ │ │ │ +

    Trait Implementations§

    1.7.0 · source§

    impl AsRef<CStr> for CString

    source§

    fn as_ref(&self) -> &CStr

    Converts this type into a shared reference of the (usually inferred) input type.
    1.3.0 · source§

    impl Borrow<CStr> for CString

    source§

    fn borrow(&self) -> &CStr

    Immutably borrows from an owned value. Read more
    source§

    impl Clone for CString

    source§

    fn clone(&self) -> CString

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.0.0 · source§

    impl Debug for CString

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.10.0 · source§

    impl Default for CString

    source§

    fn default() -> CString

    Creates an empty CString.

    │ │ │ │ +
    1.0.0 · source§

    impl Deref for CString

    §

    type Target = CStr

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &CStr

    Dereferences the value.
    1.13.0 · source§

    impl Drop for CString

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.7.0 · source§

    impl From<&CStr> for CString

    source§

    fn from(s: &CStr) -> CString

    Converts a &CStr into a CString │ │ │ │ by copying the contents into a new allocation.

    │ │ │ │ -
    1.28.0 · source§

    impl<'a> From<&'a CString> for Cow<'a, CStr>

    source§

    fn from(s: &'a CString) -> Cow<'a, CStr>

    Converts a &CString into a borrowed Cow without copying or allocating.

    │ │ │ │ -
    1.18.0 · source§

    impl From<Box<CStr>> for CString

    source§

    fn from(s: Box<CStr>) -> CString

    Converts a Box<CStr> into a CString without copying or allocating.

    │ │ │ │ -
    1.24.0 · source§

    impl From<CString> for Arc<CStr>

    source§

    fn from(s: CString) -> Arc<CStr>

    Converts a CString into an Arc<CStr> by moving the CString │ │ │ │ +

    1.28.0 · source§

    impl<'a> From<&'a CString> for Cow<'a, CStr>

    source§

    fn from(s: &'a CString) -> Cow<'a, CStr>

    Converts a &CString into a borrowed Cow without copying or allocating.

    │ │ │ │ +
    1.18.0 · source§

    impl From<Box<CStr>> for CString

    source§

    fn from(s: Box<CStr>) -> CString

    Converts a Box<CStr> into a CString without copying or allocating.

    │ │ │ │ +
    1.24.0 · source§

    impl From<CString> for Arc<CStr>

    source§

    fn from(s: CString) -> Arc<CStr>

    Converts a CString into an Arc<CStr> by moving the CString │ │ │ │ data into a new Arc buffer.

    │ │ │ │ -
    1.20.0 · source§

    impl From<CString> for Box<CStr>

    source§

    fn from(s: CString) -> Box<CStr>

    Converts a CString into a Box<CStr> without copying or allocating.

    │ │ │ │ -
    1.28.0 · source§

    impl<'a> From<CString> for Cow<'a, CStr>

    source§

    fn from(s: CString) -> Cow<'a, CStr>

    Converts a CString into an owned Cow without copying or allocating.

    │ │ │ │ -
    1.24.0 · source§

    impl From<CString> for Rc<CStr>

    source§

    fn from(s: CString) -> Rc<CStr>

    Converts a CString into an Rc<CStr> by moving the CString │ │ │ │ +

    1.20.0 · source§

    impl From<CString> for Box<CStr>

    source§

    fn from(s: CString) -> Box<CStr>

    Converts a CString into a Box<CStr> without copying or allocating.

    │ │ │ │ +
    1.28.0 · source§

    impl<'a> From<CString> for Cow<'a, CStr>

    source§

    fn from(s: CString) -> Cow<'a, CStr>

    Converts a CString into an owned Cow without copying or allocating.

    │ │ │ │ +
    1.24.0 · source§

    impl From<CString> for Rc<CStr>

    source§

    fn from(s: CString) -> Rc<CStr>

    Converts a CString into an Rc<CStr> by moving the CString │ │ │ │ data into a new Rc buffer.

    │ │ │ │ -
    1.7.0 · source§

    impl From<CString> for Vec<u8>

    source§

    fn from(s: CString) -> Vec<u8>

    Converts a CString into a Vec<u8>.

    │ │ │ │ +
    1.7.0 · source§

    impl From<CString> for Vec<u8>

    source§

    fn from(s: CString) -> Vec<u8>

    Converts a CString into a Vec<u8>.

    │ │ │ │

    The conversion consumes the CString, and removes the terminating NUL byte.

    │ │ │ │ -
    1.28.0 · source§

    impl<'a> From<Cow<'a, CStr>> for CString

    source§

    fn from(s: Cow<'a, CStr>) -> Self

    Converts a Cow<'a, CStr> into a CString, by copying the contents if they are │ │ │ │ +

    1.28.0 · source§

    impl<'a> From<Cow<'a, CStr>> for CString

    source§

    fn from(s: Cow<'a, CStr>) -> Self

    Converts a Cow<'a, CStr> into a CString, by copying the contents if they are │ │ │ │ borrowed.

    │ │ │ │ -
    1.43.0 · source§

    impl From<Vec<NonZero<u8>>> for CString

    source§

    fn from(v: Vec<NonZero<u8>>) -> CString

    Converts a Vec<NonZero<u8>> into a CString without │ │ │ │ +

    1.43.0 · source§

    impl From<Vec<NonZero<u8>>> for CString

    source§

    fn from(v: Vec<NonZero<u8>>) -> CString

    Converts a Vec<NonZero<u8>> into a CString without │ │ │ │ copying nor checking for inner nul bytes.

    │ │ │ │ -
    source§

    impl Hash for CString

    source§

    fn hash<__H: Hasher>(&self, state: &mut __H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ - H: Hasher, │ │ │ │ - Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    1.7.0 · source§

    impl Index<RangeFull> for CString

    §

    type Output = CStr

    The returned type after indexing.
    source§

    fn index(&self, _index: RangeFull) -> &CStr

    Performs the indexing (container[index]) operation. Read more
    source§

    impl Ord for CString

    source§

    fn cmp(&self, other: &CString) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ - Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq for CString

    source§

    fn eq(&self, other: &CString) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd for CString

    source§

    fn partial_cmp(&self, other: &CString) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ -operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ -operator. Read more
    source§

    impl Eq for CString

    source§

    impl StructuralPartialEq for CString

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +
    source§

    impl Hash for CString

    source§

    fn hash<__H: Hasher>(&self, state: &mut __H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ + H: Hasher, │ │ │ │ + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    1.7.0 · source§

    impl Index<RangeFull> for CString

    §

    type Output = CStr

    The returned type after indexing.
    source§

    fn index(&self, _index: RangeFull) -> &CStr

    Performs the indexing (container[index]) operation. Read more
    source§

    impl Ord for CString

    source§

    fn cmp(&self, other: &CString) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ + Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq for CString

    source§

    fn eq(&self, other: &CString) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd for CString

    source§

    fn partial_cmp(&self, other: &CString) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ +operator. Read more
    source§

    impl Eq for CString

    source§

    impl StructuralPartialEq for CString

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.FromVecWithNulError.html │ │ │ │ @@ -4,49 +4,49 @@ │ │ │ │ positioned at the end.

    │ │ │ │

    This error is created by the CString::from_vec_with_nul method. │ │ │ │ See its documentation for more.

    │ │ │ │

    §Examples

    │ │ │ │ 
    use std::ffi::{CString, FromVecWithNulError};
│ │ │ │  
│ │ │ │  let _: FromVecWithNulError = CString::from_vec_with_nul(b"f\0oo".to_vec()).unwrap_err();
    Run
    │ │ │ │ -

    Implementations§

    1.58.0 · source§

    impl FromVecWithNulError

    1.58.0 · source

    pub fn as_bytes(&self) -> &[u8]

    Returns a slice of u8s bytes that were attempted to convert to a CString.

    │ │ │ │ +

    Implementations§

    1.58.0 · source§

    impl FromVecWithNulError

    1.58.0 · source

    pub fn as_bytes(&self) -> &[u8]

    Returns a slice of u8s bytes that were attempted to convert to a CString.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  // Some invalid bytes in a vector
│ │ │ │  let bytes = b"f\0oo".to_vec();
│ │ │ │  
│ │ │ │  let value = CString::from_vec_with_nul(bytes.clone());
│ │ │ │  
│ │ │ │  assert_eq!(&bytes[..], value.unwrap_err().as_bytes());
    Run
    │ │ │ │ -
    1.58.0 · source

    pub fn into_bytes(self) -> Vec<u8>

    Returns the bytes that were attempted to convert to a CString.

    │ │ │ │ +
    1.58.0 · source

    pub fn into_bytes(self) -> Vec<u8>

    Returns the bytes that were attempted to convert to a CString.

    │ │ │ │

    This method is carefully constructed to avoid allocation. It will │ │ │ │ consume the error, moving out the bytes, so that a copy of the bytes │ │ │ │ does not need to be made.

    │ │ │ │
    §Examples
    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  // Some invalid bytes in a vector
│ │ │ │  let bytes = b"f\0oo".to_vec();
│ │ │ │  
│ │ │ │  let value = CString::from_vec_with_nul(bytes.clone());
│ │ │ │  
│ │ │ │  assert_eq!(bytes, value.unwrap_err().into_bytes());
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl Clone for FromVecWithNulError

    source§

    fn clone(&self) -> FromVecWithNulError

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for FromVecWithNulError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.58.0 · source§

    impl Display for FromVecWithNulError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.58.0 · source§

    impl Error for FromVecWithNulError

    1.30.0 · source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl PartialEq for FromVecWithNulError

    source§

    fn eq(&self, other: &FromVecWithNulError) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for FromVecWithNulError

    source§

    impl StructuralPartialEq for FromVecWithNulError

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl Clone for FromVecWithNulError

    source§

    fn clone(&self) -> FromVecWithNulError

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for FromVecWithNulError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.58.0 · source§

    impl Display for FromVecWithNulError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.58.0 · source§

    impl Error for FromVecWithNulError

    1.30.0 · source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl PartialEq for FromVecWithNulError

    source§

    fn eq(&self, other: &FromVecWithNulError) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for FromVecWithNulError

    source§

    impl StructuralPartialEq for FromVecWithNulError

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.IntoStringError.html │ │ │ │ @@ -4,22 +4,22 @@ │ │ │ │ CString::into_string performs UTF-8 validation on those bytes and may │ │ │ │ return this error.

    │ │ │ │

    This struct is created by CString::into_string(). See │ │ │ │ its documentation for more.

    │ │ │ │

    Implementations§

    source§

    impl IntoStringError

    1.7.0 · source

    pub fn into_cstring(self) -> CString

    Consumes this error, returning original CString which generated the │ │ │ │ error.

    │ │ │ │
    1.7.0 · source

    pub fn utf8_error(&self) -> Utf8Error

    Access the underlying UTF-8 error that was the cause of this error.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl Clone for IntoStringError

    source§

    fn clone(&self) -> IntoStringError

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for IntoStringError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.7.0 · source§

    impl Display for IntoStringError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.7.0 · source§

    impl Error for IntoStringError

    source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl PartialEq for IntoStringError

    source§

    fn eq(&self, other: &IntoStringError) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for IntoStringError

    source§

    impl StructuralPartialEq for IntoStringError

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl Clone for IntoStringError

    source§

    fn clone(&self) -> IntoStringError

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for IntoStringError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.7.0 · source§

    impl Display for IntoStringError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.7.0 · source§

    impl Error for IntoStringError

    source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl PartialEq for IntoStringError

    source§

    fn eq(&self, other: &IntoStringError) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for IntoStringError

    source§

    impl StructuralPartialEq for IntoStringError

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/ffi/c_str/struct.NulError.html │ │ │ │ @@ -4,39 +4,39 @@ │ │ │ │ can’t, as that byte would effectively truncate the string.

    │ │ │ │

    This error is created by the new method on │ │ │ │ CString. See its documentation for more.

    │ │ │ │

    §Examples

    │ │ │ │ 
    use std::ffi::{CString, NulError};
│ │ │ │  
│ │ │ │  let _: NulError = CString::new(b"f\0oo".to_vec()).unwrap_err();
    Run
    │ │ │ │ -

    Implementations§

    source§

    impl NulError

    1.0.0 · source

    pub fn nul_position(&self) -> usize

    Returns the position of the nul byte in the slice that caused │ │ │ │ +

    Implementations§

    source§

    impl NulError

    1.0.0 · source

    pub fn nul_position(&self) -> usize

    Returns the position of the nul byte in the slice that caused │ │ │ │ CString::new to fail.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let nul_error = CString::new("foo\0bar").unwrap_err();
│ │ │ │  assert_eq!(nul_error.nul_position(), 3);
│ │ │ │  
│ │ │ │  let nul_error = CString::new("foo bar\0").unwrap_err();
│ │ │ │  assert_eq!(nul_error.nul_position(), 7);
    Run
    │ │ │ │ -
    1.0.0 · source

    pub fn into_vec(self) -> Vec<u8>

    Consumes this error, returning the underlying vector of bytes which │ │ │ │ +

    1.0.0 · source

    pub fn into_vec(self) -> Vec<u8>

    Consumes this error, returning the underlying vector of bytes which │ │ │ │ generated the error in the first place.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let nul_error = CString::new("foo\0bar").unwrap_err();
│ │ │ │  assert_eq!(nul_error.into_vec(), b"foo\0bar");
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl Clone for NulError

    source§

    fn clone(&self) -> NulError

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for NulError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.0.0 · source§

    impl Display for NulError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.0.0 · source§

    impl Error for NulError

    source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.30.0 · source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl PartialEq for NulError

    source§

    fn eq(&self, other: &NulError) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for NulError

    source§

    impl StructuralPartialEq for NulError

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl Clone for NulError

    source§

    fn clone(&self) -> NulError

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for NulError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.0.0 · source§

    impl Display for NulError

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.0.0 · source§

    impl Error for NulError

    source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.30.0 · source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    1.0.0 · source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl PartialEq for NulError

    source§

    fn eq(&self, other: &NulError) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl Eq for NulError

    source§

    impl StructuralPartialEq for NulError

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/ffi/index.html │ │ │ │ @@ -3,15 +3,15 @@ │ │ │ │

    This module provides utilities to handle data across non-Rust │ │ │ │ interfaces, like other programming languages and the underlying │ │ │ │ operating system. It is mainly of use for FFI (Foreign Function │ │ │ │ Interface) bindings and code that needs to exchange C-like strings │ │ │ │ with other languages.

    │ │ │ │

    §Overview

    │ │ │ │

    Rust represents owned strings with the String type, and │ │ │ │ -borrowed slices of strings with the str primitive. Both are │ │ │ │ +borrowed slices of strings with the str primitive. Both are │ │ │ │ always in UTF-8 encoding, and may contain nul bytes in the middle, │ │ │ │ i.e., if you look at the bytes that make up the string, there may │ │ │ │ be a \0 among them. Both String and str store their length │ │ │ │ explicitly; there are no nul terminators at the end of strings │ │ │ │ like in C.

    │ │ │ │

    C strings are different from Rust strings:

    │ │ │ │
      │ │ │ │ @@ -24,15 +24,15 @@ │ │ │ │
    • │ │ │ │

      Character size - C strings may use char or wchar_t-sized │ │ │ │ characters; please note that C’s char is different from Rust’s. │ │ │ │ The C standard leaves the actual sizes of those types open to │ │ │ │ interpretation, but defines different APIs for strings made up of │ │ │ │ each character type. Rust strings are always UTF-8, so different │ │ │ │ Unicode characters will be encoded in a variable number of bytes │ │ │ │ -each. The Rust type char represents a ‘[Unicode scalar │ │ │ │ +each. The Rust type char represents a ‘[Unicode scalar │ │ │ │ value]’, which is similar to, but not the same as, a ‘[Unicode │ │ │ │ code point]’.

      │ │ │ │
      • │ │ │ │
    • │ │ │ │

      Nul terminators and implicit string lengths - Often, C │ │ │ │ strings are nul-terminated, i.e., they have a \0 character at the │ │ │ │ end. The length of a string buffer is not stored, but has to be │ │ │ │ @@ -54,30 +54,30 @@ │ │ │ │ characters in the middle — a nul character would essentially │ │ │ │ truncate the string. Rust strings can have nul characters in │ │ │ │ the middle, because nul does not have to mark the end of the │ │ │ │ string in Rust.

      │ │ │ │
      • │ │ │ │
    │ │ │ │

    §Representations of non-Rust strings

    │ │ │ │ -

    CString and CStr are useful when you need to transfer │ │ │ │ +

    CString and CStr are useful when you need to transfer │ │ │ │ UTF-8 strings to and from languages with a C ABI, like Python.

    │ │ │ │
      │ │ │ │
    • │ │ │ │

      From Rust to C: CString represents an owned, C-friendly │ │ │ │ string: it is nul-terminated, and has no internal nul characters. │ │ │ │ Rust code can create a CString out of a normal string (provided │ │ │ │ that the string doesn’t have nul characters in the middle), and │ │ │ │ -then use a variety of methods to obtain a raw *mut u8 that can │ │ │ │ +then use a variety of methods to obtain a raw *mut u8 that can │ │ │ │ then be passed as an argument to functions which use the C │ │ │ │ conventions for strings.

      │ │ │ │
      • │ │ │ │
    • │ │ │ │ -

      From C to Rust: CStr represents a borrowed C string; it │ │ │ │ -is what you would use to wrap a raw *const u8 that you got from │ │ │ │ -a C function. A CStr is guaranteed to be a nul-terminated array │ │ │ │ -of bytes. Once you have a CStr, you can convert it to a Rust │ │ │ │ -&str if it’s valid UTF-8, or lossily convert it by adding │ │ │ │ +

      From C to Rust: CStr represents a borrowed C string; it │ │ │ │ +is what you would use to wrap a raw *const u8 that you got from │ │ │ │ +a C function. A CStr is guaranteed to be a nul-terminated array │ │ │ │ +of bytes. Once you have a CStr, you can convert it to a Rust │ │ │ │ +&str if it’s valid UTF-8, or lossily convert it by adding │ │ │ │ replacement characters.

      │ │ │ │
      • │ │ │ │
    │ │ │ │

    Re-exports§

    Modules§

    Structs§

    • CString
      A type representing an owned, C-compatible, nul-terminated string with no nul bytes in the │ │ │ │ middle.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/ffi/struct.CString.html │ │ │ │ @@ -1,45 +1,45 @@ │ │ │ │ CString in alloc::ffi - Rust
    │ │ │ │

    Struct alloc::ffi::CString

    1.64.0 · source · 
    pub struct CString { /* private fields */ }
    Expand description

    A type representing an owned, C-compatible, nul-terminated string with no nul bytes in the │ │ │ │ middle.

    │ │ │ │

    This type serves the purpose of being able to safely generate a │ │ │ │ C-compatible string from a Rust byte slice or vector. An instance of this │ │ │ │ type is a static guarantee that the underlying bytes contain no interior 0 │ │ │ │ bytes (“nul characters”) and that the final byte is 0 (“nul terminator”).

    │ │ │ │ -

    CString is to &CStr as String is to &str: the former │ │ │ │ +

    CString is to &CStr as String is to &str: the former │ │ │ │ in each pair are owned strings; the latter are borrowed │ │ │ │ references.

    │ │ │ │

    §Creating a CString

    │ │ │ │

    A CString is created from either a byte slice or a byte vector, │ │ │ │ -or anything that implements Into<Vec<u8>> (for │ │ │ │ +or anything that implements Into<Vec<u8>> (for │ │ │ │ example, you can build a CString straight out of a String or │ │ │ │ -a &str, since both implement that trait).

    │ │ │ │ -

    The CString::new method will actually check that the provided &[u8] │ │ │ │ +a &str, since both implement that trait).

    │ │ │ │ +

    The CString::new method will actually check that the provided &[u8] │ │ │ │ does not have 0 bytes in the middle, and return an error if it │ │ │ │ finds one.

    │ │ │ │

    §Extracting a raw pointer to the whole C string

    │ │ │ │ -

    CString implements an as_ptr method through the Deref │ │ │ │ +

    CString implements an as_ptr method through the Deref │ │ │ │ trait. This method will give you a *const c_char which you can │ │ │ │ feed directly to extern functions that expect a nul-terminated │ │ │ │ -string, like C’s strdup(). Notice that as_ptr returns a │ │ │ │ +string, like C’s strdup(). Notice that as_ptr returns a │ │ │ │ read-only pointer; if the C code writes to it, that causes │ │ │ │ undefined behavior.

    │ │ │ │

    §Extracting a slice of the whole C string

    │ │ │ │ -

    Alternatively, you can obtain a &[u8] slice from a │ │ │ │ +

    Alternatively, you can obtain a &[u8] slice from a │ │ │ │ CString with the CString::as_bytes method. Slices produced in this │ │ │ │ way do not contain the trailing nul terminator. This is useful │ │ │ │ when you will be calling an extern function that takes a *const u8 argument which is not necessarily nul-terminated, plus another │ │ │ │ argument with the length of the string — like C’s strndup(). │ │ │ │ You can of course get the slice’s length with its │ │ │ │ -len method.

    │ │ │ │ -

    If you need a &[u8] slice with the nul terminator, you │ │ │ │ +len method.

    │ │ │ │ +

    If you need a &[u8] slice with the nul terminator, you │ │ │ │ can use CString::as_bytes_with_nul instead.

    │ │ │ │

    Once you have the kind of slice you need (with or without a nul │ │ │ │ terminator), you can call the slice’s own │ │ │ │ -as_ptr method to get a read-only raw pointer to pass to │ │ │ │ +as_ptr method to get a read-only raw pointer to pass to │ │ │ │ extern functions. See the documentation for that function for a │ │ │ │ discussion on ensuring the lifetime of the raw pointer.

    │ │ │ │

    §Examples

    │ │ │ │
    ⓘ
    use std::ffi::CString;
│ │ │ │  use std::os::raw::c_char;
│ │ │ │  
│ │ │ │  extern "C" {
│ │ │ │ @@ -57,15 +57,15 @@
│ │ │ │  (a sequence of non-nul bytes terminated by a single nul byte); the
│ │ │ │  primary use case for these kinds of strings is interoperating with C-like
│ │ │ │  code. Often you will need to transfer ownership to/from that external
│ │ │ │  code. It is strongly recommended that you thoroughly read through the
│ │ │ │  documentation of CString before use, as improper ownership management
│ │ │ │  of CString instances can lead to invalid memory accesses, memory leaks,
│ │ │ │  and other memory errors.
    
│ │ │ │ -

    Implementations§

    source§

    impl CString

    1.0.0 · source

    pub fn new<T: Into<Vec<u8>>>(t: T) -> Result<CString, NulError>

    Creates a new C-compatible string from a container of bytes.

    │ │ │ │ +

    Implementations§

    source§

    impl CString

    1.0.0 · source

    pub fn new<T: Into<Vec<u8>>>(t: T) -> Result<CString, NulError>

    Creates a new C-compatible string from a container of bytes.

    │ │ │ │

    This function will consume the provided data and use the │ │ │ │ underlying bytes to construct a new string, ensuring that │ │ │ │ there is a trailing 0 byte. This trailing 0 byte will be │ │ │ │ appended by this function; the provided data should not │ │ │ │ contain any 0 bytes in it.

    │ │ │ │
    §Examples
    │ │ │ │
    ⓘ
    use std::ffi::CString;
│ │ │ │ @@ -77,43 +77,43 @@
│ │ │ │  unsafe {
│ │ │ │      puts(to_print.as_ptr());
│ │ │ │  }
    Run
    │ │ │ │
    §Errors
    │ │ │ │

    This function will return an error if the supplied bytes contain an │ │ │ │ internal 0 byte. The NulError returned will contain the bytes as well as │ │ │ │ the position of the nul byte.

    │ │ │ │ -
    1.0.0 · source

    pub unsafe fn from_vec_unchecked(v: Vec<u8>) -> Self

    Creates a C-compatible string by consuming a byte vector, │ │ │ │ +

    1.0.0 · source

    pub unsafe fn from_vec_unchecked(v: Vec<u8>) -> Self

    Creates a C-compatible string by consuming a byte vector, │ │ │ │ without checking for interior 0 bytes.

    │ │ │ │

    Trailing 0 byte will be appended by this function.

    │ │ │ │

    This method is equivalent to CString::new except that no runtime │ │ │ │ assertion is made that v contains no 0 bytes, and it requires an │ │ │ │ actual byte vector, not anything that can be converted to one with Into.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let raw = b"foo".to_vec();
│ │ │ │  unsafe {
│ │ │ │      let c_string = CString::from_vec_unchecked(raw);
│ │ │ │  }
    Run
    │ │ │ │ -
    1.4.0 · source

    pub unsafe fn from_raw(ptr: *mut c_char) -> CString

    Retakes ownership of a CString that was transferred to C via │ │ │ │ +

    1.4.0 · source

    pub unsafe fn from_raw(ptr: *mut c_char) -> CString

    Retakes ownership of a CString that was transferred to C via │ │ │ │ CString::into_raw.

    │ │ │ │

    Additionally, the length of the string will be recalculated from the pointer.

    │ │ │ │
    §Safety
    │ │ │ │

    This should only ever be called with a pointer that was earlier │ │ │ │ obtained by calling CString::into_raw. Other usage (e.g., trying to take │ │ │ │ ownership of a string that was allocated by foreign code) is likely to lead │ │ │ │ to undefined behavior or allocator corruption.

    │ │ │ │

    It should be noted that the length isn’t just “recomputed,” but that │ │ │ │ the recomputed length must match the original length from the │ │ │ │ CString::into_raw call. This means the CString::into_raw/from_raw │ │ │ │ methods should not be used when passing the string to C functions that can │ │ │ │ modify the string’s length.

    │ │ │ │
    │ │ │ │

    Note: If you need to borrow a string that was allocated by │ │ │ │ -foreign code, use CStr. If you need to take ownership of │ │ │ │ +foreign code, use CStr. If you need to take ownership of │ │ │ │ a string that was allocated by foreign code, you will need to │ │ │ │ make your own provisions for freeing it appropriately, likely │ │ │ │ with the foreign code’s API to do that.

    │ │ │ │
    │ │ │ │
    §Examples
    │ │ │ │

    Creates a CString, pass ownership to an extern function (via raw pointer), then retake │ │ │ │ ownership with from_raw:

    │ │ │ │ @@ -127,15 +127,15 @@ │ │ │ │ │ │ │ │ let c_string = CString::new("Hello!").expect("CString::new failed"); │ │ │ │ let raw = c_string.into_raw(); │ │ │ │ unsafe { │ │ │ │ some_extern_function(raw); │ │ │ │ let c_string = CString::from_raw(raw); │ │ │ │ }    Run
    │ │ │ │ -
    1.4.0 · source

    pub fn into_raw(self) -> *mut c_char

    Consumes the CString and transfers ownership of the string to a C caller.

    │ │ │ │ +
    1.4.0 · source

    pub fn into_raw(self) -> *mut c_char

    Consumes the CString and transfers ownership of the string to a C caller.

    │ │ │ │

    The pointer which this function returns must be returned to Rust and reconstituted using │ │ │ │ CString::from_raw to be properly deallocated. Specifically, one │ │ │ │ should not use the standard C free() function to deallocate │ │ │ │ this string.

    │ │ │ │

    Failure to call CString::from_raw will lead to a memory leak.

    │ │ │ │

    The C side must not modify the length of the string (by writing a │ │ │ │ nul byte somewhere inside the string or removing the final one) before │ │ │ │ @@ -153,92 +153,92 @@ │ │ │ │ assert_eq!(b'o', *ptr.add(1) as u8); │ │ │ │ assert_eq!(b'o', *ptr.add(2) as u8); │ │ │ │ assert_eq!(b'\0', *ptr.add(3) as u8); │ │ │ │ │ │ │ │ // retake pointer to free memory │ │ │ │ let _ = CString::from_raw(ptr); │ │ │ │ }Run

    │ │ │ │ -
    1.7.0 · source

    pub fn into_string(self) -> Result<String, IntoStringError>

    Converts the CString into a String if it contains valid UTF-8 data.

    │ │ │ │ +
    1.7.0 · source

    pub fn into_string(self) -> Result<String, IntoStringError>

    Converts the CString into a String if it contains valid UTF-8 data.

    │ │ │ │

    On failure, ownership of the original CString is returned.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let valid_utf8 = vec![b'f', b'o', b'o'];
│ │ │ │  let cstring = CString::new(valid_utf8).expect("CString::new failed");
│ │ │ │  assert_eq!(cstring.into_string().expect("into_string() call failed"), "foo");
│ │ │ │  
│ │ │ │  let invalid_utf8 = vec![b'f', 0xff, b'o', b'o'];
│ │ │ │  let cstring = CString::new(invalid_utf8).expect("CString::new failed");
│ │ │ │  let err = cstring.into_string().err().expect("into_string().err() failed");
│ │ │ │  assert_eq!(err.utf8_error().valid_up_to(), 1);
    Run
    │ │ │ │ -
    1.7.0 · source

    pub fn into_bytes(self) -> Vec<u8>

    Consumes the CString and returns the underlying byte buffer.

    │ │ │ │ +
    1.7.0 · source

    pub fn into_bytes(self) -> Vec<u8>

    Consumes the CString and returns the underlying byte buffer.

    │ │ │ │

    The returned buffer does not contain the trailing nul │ │ │ │ terminator, and it is guaranteed to not have any interior nul │ │ │ │ bytes.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let c_string = CString::new("foo").expect("CString::new failed");
│ │ │ │  let bytes = c_string.into_bytes();
│ │ │ │  assert_eq!(bytes, vec![b'f', b'o', b'o']);
    Run
    │ │ │ │ -
    1.7.0 · source

    pub fn into_bytes_with_nul(self) -> Vec<u8>

    Equivalent to CString::into_bytes() except that the │ │ │ │ +

    1.7.0 · source

    pub fn into_bytes_with_nul(self) -> Vec<u8>

    Equivalent to CString::into_bytes() except that the │ │ │ │ returned vector includes the trailing nul terminator.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let c_string = CString::new("foo").expect("CString::new failed");
│ │ │ │  let bytes = c_string.into_bytes_with_nul();
│ │ │ │  assert_eq!(bytes, vec![b'f', b'o', b'o', b'\0']);
    Run
    │ │ │ │ -
    1.0.0 · source

    pub fn as_bytes(&self) -> &[u8]

    Returns the contents of this CString as a slice of bytes.

    │ │ │ │ +
    1.0.0 · source

    pub fn as_bytes(&self) -> &[u8]

    Returns the contents of this CString as a slice of bytes.

    │ │ │ │

    The returned slice does not contain the trailing nul │ │ │ │ terminator, and it is guaranteed to not have any interior nul │ │ │ │ bytes. If you need the nul terminator, use │ │ │ │ CString::as_bytes_with_nul instead.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let c_string = CString::new("foo").expect("CString::new failed");
│ │ │ │  let bytes = c_string.as_bytes();
│ │ │ │  assert_eq!(bytes, &[b'f', b'o', b'o']);
    Run
    │ │ │ │ -
    1.0.0 · source

    pub fn as_bytes_with_nul(&self) -> &[u8]

    Equivalent to CString::as_bytes() except that the │ │ │ │ +

    1.0.0 · source

    pub fn as_bytes_with_nul(&self) -> &[u8]

    Equivalent to CString::as_bytes() except that the │ │ │ │ returned slice includes the trailing nul terminator.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  
│ │ │ │  let c_string = CString::new("foo").expect("CString::new failed");
│ │ │ │  let bytes = c_string.as_bytes_with_nul();
│ │ │ │  assert_eq!(bytes, &[b'f', b'o', b'o', b'\0']);
    Run
    │ │ │ │ -
    1.20.0 · source

    pub fn as_c_str(&self) -> &CStr

    Extracts a CStr slice containing the entire string.

    │ │ │ │ +
    1.20.0 · source

    pub fn as_c_str(&self) -> &CStr

    Extracts a CStr slice containing the entire string.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::{CString, CStr};
│ │ │ │  
│ │ │ │  let c_string = CString::new(b"foo".to_vec()).expect("CString::new failed");
│ │ │ │  let cstr = c_string.as_c_str();
│ │ │ │  assert_eq!(cstr,
│ │ │ │             CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed"));
    Run
    │ │ │ │ -
    1.20.0 · source

    pub fn into_boxed_c_str(self) -> Box<CStr>

    Converts this CString into a boxed CStr.

    │ │ │ │ +
    1.20.0 · source

    pub fn into_boxed_c_str(self) -> Box<CStr>

    Converts this CString into a boxed CStr.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::{CString, CStr};
│ │ │ │  
│ │ │ │  let c_string = CString::new(b"foo".to_vec()).expect("CString::new failed");
│ │ │ │  let boxed = c_string.into_boxed_c_str();
│ │ │ │  assert_eq!(&*boxed,
│ │ │ │             CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed"));
    Run
    │ │ │ │ -
    1.58.0 · source

    pub unsafe fn from_vec_with_nul_unchecked(v: Vec<u8>) -> Self

    Converts a Vec<u8> to a CString without checking the │ │ │ │ +

    1.58.0 · source

    pub unsafe fn from_vec_with_nul_unchecked(v: Vec<u8>) -> Self

    Converts a Vec<u8> to a CString without checking the │ │ │ │ invariants on the given Vec.

    │ │ │ │
    §Safety
    │ │ │ │

    The given Vec must have one nul byte as its last element. │ │ │ │ This means it cannot be empty nor have any other nul byte anywhere else.

    │ │ │ │
    §Example
    │ │ │ │ 
    use std::ffi::CString;
│ │ │ │  assert_eq!(
│ │ │ │      unsafe { CString::from_vec_with_nul_unchecked(b"abc\0".to_vec()) },
│ │ │ │      unsafe { CString::from_vec_unchecked(b"abc".to_vec()) }
│ │ │ │  );
    Run
    │ │ │ │ -
    1.58.0 · source

    pub fn from_vec_with_nul(v: Vec<u8>) -> Result<Self, FromVecWithNulError>

    Attempts to converts a Vec<u8> to a CString.

    │ │ │ │ +
    1.58.0 · source

    pub fn from_vec_with_nul(v: Vec<u8>) -> Result<Self, FromVecWithNulError>

    Attempts to converts a Vec<u8> to a CString.

    │ │ │ │

    Runtime checks are present to ensure there is only one nul byte in the │ │ │ │ Vec, its last element.

    │ │ │ │
    §Errors
    │ │ │ │

    If a nul byte is present and not the last element or no nul bytes │ │ │ │ is present, an error will be returned.

    │ │ │ │
    §Examples
    │ │ │ │

    A successful conversion will produce the same result as CString::new │ │ │ │ @@ -253,21 +253,21 @@ │ │ │ │

    An incorrectly formatted Vec will produce an error.

    │ │ │ │ │ │ │ │ 
    use std::ffi::{CString, FromVecWithNulError};
│ │ │ │  // Interior nul byte
│ │ │ │  let _: FromVecWithNulError = CString::from_vec_with_nul(b"a\0bc".to_vec()).unwrap_err();
│ │ │ │  // No nul byte
│ │ │ │  let _: FromVecWithNulError = CString::from_vec_with_nul(b"abc".to_vec()).unwrap_err();
    Run
    │ │ │ │ -

    Methods from Deref<Target = CStr>§

    1.4.0 · source

    pub fn to_string_lossy(&self) -> Cow<'_, str>

    Converts a CStr into a Cow<str>.

    │ │ │ │ +

    Methods from Deref<Target = CStr>§

    1.4.0 · source

    pub fn to_string_lossy(&self) -> Cow<'_, str>

    Converts a CStr into a Cow<str>.

    │ │ │ │

    If the contents of the CStr are valid UTF-8 data, this │ │ │ │ -function will return a Cow::Borrowed(&str) │ │ │ │ -with the corresponding &str slice. Otherwise, it will │ │ │ │ +function will return a Cow::Borrowed(&str) │ │ │ │ +with the corresponding &str slice. Otherwise, it will │ │ │ │ replace any invalid UTF-8 sequences with │ │ │ │ -U+FFFD REPLACEMENT CHARACTER and return a │ │ │ │ -Cow::Owned(&str) with the result.

    │ │ │ │ +U+FFFD REPLACEMENT CHARACTER and return a │ │ │ │ +Cow::Owned(&str) with the result.

    │ │ │ │
    §Examples
    │ │ │ │

    Calling to_string_lossy on a CStr containing valid UTF-8:

    │ │ │ │ │ │ │ │ 
    use std::borrow::Cow;
│ │ │ │  use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"Hello World\0")
│ │ │ │ @@ -280,20 +280,20 @@
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"Hello \xF0\x90\x80World\0")
│ │ │ │                   .expect("CStr::from_bytes_with_nul failed");
│ │ │ │  assert_eq!(
│ │ │ │      cstr.to_string_lossy(),
│ │ │ │      Cow::Owned(String::from("Hello �World")) as Cow<'_, str>
│ │ │ │  );
    Run
    │ │ │ │ -
    1.0.0 · source

    pub fn as_ptr(&self) -> *const i8

    Returns the inner pointer to this C string.

    │ │ │ │ +
    1.0.0 · source

    pub fn as_ptr(&self) -> *const i8

    Returns the inner pointer to this C string.

    │ │ │ │

    The returned pointer will be valid for as long as self is, and points │ │ │ │ to a contiguous region of memory terminated with a 0 byte to represent │ │ │ │ the end of the string.

    │ │ │ │

    The type of the returned pointer is │ │ │ │ -*const c_char, and whether it’s │ │ │ │ +*const c_char, and whether it’s │ │ │ │ an alias for *const i8 or *const u8 is platform-specific.

    │ │ │ │

    WARNING

    │ │ │ │

    The returned pointer is read-only; writing to it (including passing it │ │ │ │ to C code that writes to it) causes undefined behavior.

    │ │ │ │

    It is your responsibility to make sure that the underlying memory is not │ │ │ │ freed too early. For example, the following code will cause undefined │ │ │ │ behavior when ptr is used inside the unsafe block:

    │ │ │ │ @@ -318,15 +318,15 @@ │ │ │ │ let ptr = hello.as_ptr(); │ │ │ │ unsafe { │ │ │ │ // `ptr` is valid because `hello` is in scope │ │ │ │ *ptr; │ │ │ │ }Run
    │ │ │ │

    This way, the lifetime of the CString in hello encompasses │ │ │ │ the lifetime of ptr and the unsafe block.

    │ │ │ │ -
    source

    pub fn count_bytes(&self) -> usize

    🔬This is a nightly-only experimental API. (cstr_count_bytes #114441)

    Returns the length of self. Like C’s strlen, this does not include the nul terminator.

    │ │ │ │ +
    source

    pub fn count_bytes(&self) -> usize

    🔬This is a nightly-only experimental API. (cstr_count_bytes #114441)

    Returns the length of self. Like C’s strlen, this does not include the nul terminator.

    │ │ │ │
    │ │ │ │

    Note: This method is currently implemented as a constant-time │ │ │ │ cast, but it is planned to alter its definition in the future to │ │ │ │ perform the length calculation whenever this method is called.

    │ │ │ │
    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(cstr_count_bytes)]
│ │ │ │ @@ -334,98 +334,98 @@
│ │ │ │  use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0").unwrap();
│ │ │ │  assert_eq!(cstr.count_bytes(), 3);
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"\0").unwrap();
│ │ │ │  assert_eq!(cstr.count_bytes(), 0);
    Run
    │ │ │ │ -
    1.71.0 · source

    pub fn is_empty(&self) -> bool

    Returns true if self.to_bytes() has a length of 0.

    │ │ │ │ +
    1.71.0 · source

    pub fn is_empty(&self) -> bool

    Returns true if self.to_bytes() has a length of 0.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0")?;
│ │ │ │  assert!(!cstr.is_empty());
│ │ │ │  
│ │ │ │  let empty_cstr = CStr::from_bytes_with_nul(b"\0")?;
│ │ │ │  assert!(empty_cstr.is_empty());
    Run
    │ │ │ │ -
    1.0.0 · source

    pub fn to_bytes(&self) -> &[u8]

    Converts this C string to a byte slice.

    │ │ │ │ +
    1.0.0 · source

    pub fn to_bytes(&self) -> &[u8]

    Converts this C string to a byte slice.

    │ │ │ │

    The returned slice will not contain the trailing nul terminator that this C │ │ │ │ string has.

    │ │ │ │
    │ │ │ │

    Note: This method is currently implemented as a constant-time │ │ │ │ cast, but it is planned to alter its definition in the future to │ │ │ │ perform the length calculation whenever this method is called.

    │ │ │ │
    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
│ │ │ │  assert_eq!(cstr.to_bytes(), b"foo");
    Run
    │ │ │ │ -
    1.0.0 · source

    pub fn to_bytes_with_nul(&self) -> &[u8]

    Converts this C string to a byte slice containing the trailing 0 byte.

    │ │ │ │ -

    This function is the equivalent of CStr::to_bytes except that it │ │ │ │ +

    1.0.0 · source

    pub fn to_bytes_with_nul(&self) -> &[u8]

    Converts this C string to a byte slice containing the trailing 0 byte.

    │ │ │ │ +

    This function is the equivalent of CStr::to_bytes except that it │ │ │ │ will retain the trailing nul terminator instead of chopping it off.

    │ │ │ │
    │ │ │ │

    Note: This method is currently implemented as a 0-cost cast, but │ │ │ │ it is planned to alter its definition in the future to perform the │ │ │ │ length calculation whenever this method is called.

    │ │ │ │
    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
│ │ │ │  assert_eq!(cstr.to_bytes_with_nul(), b"foo\0");
    Run
    │ │ │ │ -
    source

    pub fn bytes(&self) -> Bytes<'_>

    🔬This is a nightly-only experimental API. (cstr_bytes #112115)

    Iterates over the bytes in this C string.

    │ │ │ │ +
    source

    pub fn bytes(&self) -> Bytes<'_>

    🔬This is a nightly-only experimental API. (cstr_bytes #112115)

    Iterates over the bytes in this C string.

    │ │ │ │

    The returned iterator will not contain the trailing nul terminator │ │ │ │ that this C string has.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(cstr_bytes)]
│ │ │ │  use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
│ │ │ │  assert!(cstr.bytes().eq(*b"foo"));
    Run
    │ │ │ │ -
    1.4.0 · source

    pub fn to_str(&self) -> Result<&str, Utf8Error>

    Yields a &str slice if the CStr contains valid UTF-8.

    │ │ │ │ +
    1.4.0 · source

    pub fn to_str(&self) -> Result<&str, Utf8Error>

    Yields a &str slice if the CStr contains valid UTF-8.

    │ │ │ │

    If the contents of the CStr are valid UTF-8 data, this │ │ │ │ -function will return the corresponding &str slice. Otherwise, │ │ │ │ +function will return the corresponding &str slice. Otherwise, │ │ │ │ it will return an error with details of where UTF-8 validation failed.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::ffi::CStr;
│ │ │ │  
│ │ │ │  let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
│ │ │ │  assert_eq!(cstr.to_str(), Ok("foo"));
    Run
    │ │ │ │ -

    Trait Implementations§

    1.7.0 · source§

    impl AsRef<CStr> for CString

    source§

    fn as_ref(&self) -> &CStr

    Converts this type into a shared reference of the (usually inferred) input type.
    1.3.0 · source§

    impl Borrow<CStr> for CString

    source§

    fn borrow(&self) -> &CStr

    Immutably borrows from an owned value. Read more
    source§

    impl Clone for CString

    source§

    fn clone(&self) -> CString

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.0.0 · source§

    impl Debug for CString

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.10.0 · source§

    impl Default for CString

    source§

    fn default() -> CString

    Creates an empty CString.

    │ │ │ │ -
    1.0.0 · source§

    impl Deref for CString

    §

    type Target = CStr

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &CStr

    Dereferences the value.
    1.13.0 · source§

    impl Drop for CString

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.7.0 · source§

    impl From<&CStr> for CString

    source§

    fn from(s: &CStr) -> CString

    Converts a &CStr into a CString │ │ │ │ +

    Trait Implementations§

    1.7.0 · source§

    impl AsRef<CStr> for CString

    source§

    fn as_ref(&self) -> &CStr

    Converts this type into a shared reference of the (usually inferred) input type.
    1.3.0 · source§

    impl Borrow<CStr> for CString

    source§

    fn borrow(&self) -> &CStr

    Immutably borrows from an owned value. Read more
    source§

    impl Clone for CString

    source§

    fn clone(&self) -> CString

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.0.0 · source§

    impl Debug for CString

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.10.0 · source§

    impl Default for CString

    source§

    fn default() -> CString

    Creates an empty CString.

    │ │ │ │ +
    1.0.0 · source§

    impl Deref for CString

    §

    type Target = CStr

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &CStr

    Dereferences the value.
    1.13.0 · source§

    impl Drop for CString

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more
    1.7.0 · source§

    impl From<&CStr> for CString

    source§

    fn from(s: &CStr) -> CString

    Converts a &CStr into a CString │ │ │ │ by copying the contents into a new allocation.

    │ │ │ │ -
    1.28.0 · source§

    impl<'a> From<&'a CString> for Cow<'a, CStr>

    source§

    fn from(s: &'a CString) -> Cow<'a, CStr>

    Converts a &CString into a borrowed Cow without copying or allocating.

    │ │ │ │ -
    1.18.0 · source§

    impl From<Box<CStr>> for CString

    source§

    fn from(s: Box<CStr>) -> CString

    Converts a Box<CStr> into a CString without copying or allocating.

    │ │ │ │ -
    1.24.0 · source§

    impl From<CString> for Arc<CStr>

    source§

    fn from(s: CString) -> Arc<CStr>

    Converts a CString into an Arc<CStr> by moving the CString │ │ │ │ +

    1.28.0 · source§

    impl<'a> From<&'a CString> for Cow<'a, CStr>

    source§

    fn from(s: &'a CString) -> Cow<'a, CStr>

    Converts a &CString into a borrowed Cow without copying or allocating.

    │ │ │ │ +
    1.18.0 · source§

    impl From<Box<CStr>> for CString

    source§

    fn from(s: Box<CStr>) -> CString

    Converts a Box<CStr> into a CString without copying or allocating.

    │ │ │ │ +
    1.24.0 · source§

    impl From<CString> for Arc<CStr>

    source§

    fn from(s: CString) -> Arc<CStr>

    Converts a CString into an Arc<CStr> by moving the CString │ │ │ │ data into a new Arc buffer.

    │ │ │ │ -
    1.20.0 · source§

    impl From<CString> for Box<CStr>

    source§

    fn from(s: CString) -> Box<CStr>

    Converts a CString into a Box<CStr> without copying or allocating.

    │ │ │ │ -
    1.28.0 · source§

    impl<'a> From<CString> for Cow<'a, CStr>

    source§

    fn from(s: CString) -> Cow<'a, CStr>

    Converts a CString into an owned Cow without copying or allocating.

    │ │ │ │ -
    1.24.0 · source§

    impl From<CString> for Rc<CStr>

    source§

    fn from(s: CString) -> Rc<CStr>

    Converts a CString into an Rc<CStr> by moving the CString │ │ │ │ +

    1.20.0 · source§

    impl From<CString> for Box<CStr>

    source§

    fn from(s: CString) -> Box<CStr>

    Converts a CString into a Box<CStr> without copying or allocating.

    │ │ │ │ +
    1.28.0 · source§

    impl<'a> From<CString> for Cow<'a, CStr>

    source§

    fn from(s: CString) -> Cow<'a, CStr>

    Converts a CString into an owned Cow without copying or allocating.

    │ │ │ │ +
    1.24.0 · source§

    impl From<CString> for Rc<CStr>

    source§

    fn from(s: CString) -> Rc<CStr>

    Converts a CString into an Rc<CStr> by moving the CString │ │ │ │ data into a new Rc buffer.

    │ │ │ │ -
    1.7.0 · source§

    impl From<CString> for Vec<u8>

    source§

    fn from(s: CString) -> Vec<u8>

    Converts a CString into a Vec<u8>.

    │ │ │ │ +
    1.7.0 · source§

    impl From<CString> for Vec<u8>

    source§

    fn from(s: CString) -> Vec<u8>

    Converts a CString into a Vec<u8>.

    │ │ │ │

    The conversion consumes the CString, and removes the terminating NUL byte.

    │ │ │ │ -
    1.28.0 · source§

    impl<'a> From<Cow<'a, CStr>> for CString

    source§

    fn from(s: Cow<'a, CStr>) -> Self

    Converts a Cow<'a, CStr> into a CString, by copying the contents if they are │ │ │ │ +

    1.28.0 · source§

    impl<'a> From<Cow<'a, CStr>> for CString

    source§

    fn from(s: Cow<'a, CStr>) -> Self

    Converts a Cow<'a, CStr> into a CString, by copying the contents if they are │ │ │ │ borrowed.

    │ │ │ │ -
    1.43.0 · source§

    impl From<Vec<NonZero<u8>>> for CString

    source§

    fn from(v: Vec<NonZero<u8>>) -> CString

    Converts a Vec<NonZero<u8>> into a CString without │ │ │ │ +

    1.43.0 · source§

    impl From<Vec<NonZero<u8>>> for CString

    source§

    fn from(v: Vec<NonZero<u8>>) -> CString

    Converts a Vec<NonZero<u8>> into a CString without │ │ │ │ copying nor checking for inner nul bytes.

    │ │ │ │ -
    source§

    impl Hash for CString

    source§

    fn hash<__H: Hasher>(&self, state: &mut __H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ - H: Hasher, │ │ │ │ - Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    1.7.0 · source§

    impl Index<RangeFull> for CString

    §

    type Output = CStr

    The returned type after indexing.
    source§

    fn index(&self, _index: RangeFull) -> &CStr

    Performs the indexing (container[index]) operation. Read more
    source§

    impl Ord for CString

    source§

    fn cmp(&self, other: &CString) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ - Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq for CString

    source§

    fn eq(&self, other: &CString) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd for CString

    source§

    fn partial_cmp(&self, other: &CString) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ -operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ -operator. Read more
    source§

    impl Eq for CString

    source§

    impl StructuralPartialEq for CString

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +
    source§

    impl Hash for CString

    source§

    fn hash<__H: Hasher>(&self, state: &mut __H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ + H: Hasher, │ │ │ │ + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    1.7.0 · source§

    impl Index<RangeFull> for CString

    §

    type Output = CStr

    The returned type after indexing.
    source§

    fn index(&self, _index: RangeFull) -> &CStr

    Performs the indexing (container[index]) operation. Read more
    source§

    impl Ord for CString

    source§

    fn cmp(&self, other: &CString) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ + Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq for CString

    source§

    fn eq(&self, other: &CString) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd for CString

    source§

    fn partial_cmp(&self, other: &CString) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ +operator. Read more
    source§

    impl Eq for CString

    source§

    impl StructuralPartialEq for CString

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/derive.Debug.html │ │ │ │ @@ -1,3 +1,3 @@ │ │ │ │ Debug in alloc::fmt - Rust
    │ │ │ │ -

    Derive Macro alloc::fmt::Debug

    1.38.0 · source · 
    #[derive(Debug)]
    Expand description

    Derive macro generating an impl of the trait Debug.

    │ │ │ │ +

    Derive Macro alloc::fmt::Debug

    1.38.0 · source · 
    #[derive(Debug)]
    Expand description

    Derive macro generating an impl of the trait Debug.

    │ │ │ │
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/enum.Alignment.html │ │ │ │ @@ -1,23 +1,23 @@ │ │ │ │ Alignment in alloc::fmt - Rust
    │ │ │ │ -

    Enum alloc::fmt::Alignment

    1.28.0 · source · 
    pub enum Alignment {
│ │ │ │ +    
    Enum alloc::fmt::Alignment
    1.28.0 · source · 
    pub enum Alignment {
│ │ │ │      Left,
│ │ │ │      Right,
│ │ │ │      Center,
│ │ │ │  }
    Expand description
    Possible alignments returned by Formatter::align
    
│ │ │ │  
    Variants§
    §
    Left
    Indication that contents should be left-aligned.
    
│ │ │ │  
    §
    Right
    Indication that contents should be right-aligned.
    
│ │ │ │  
    §
    Center
    Indication that contents should be center-aligned.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl Clone for Alignment
    source§
    fn clone(&self) -> Alignment
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for Alignment
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl PartialEq for Alignment
    source§
    fn eq(&self, other: &Alignment) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    1.0.0 · source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl Copy for Alignment
    source§
    impl Eq for Alignment
    source§
    impl StructuralPartialEq for Alignment
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl Clone for Alignment
    source§
    fn clone(&self) -> Alignment
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for Alignment
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl PartialEq for Alignment
    source§
    fn eq(&self, other: &Alignment) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    1.0.0 · source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl Copy for Alignment
    source§
    impl Eq for Alignment
    source§
    impl StructuralPartialEq for Alignment
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │  
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +    T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/fn.format.html │ │ │ │ @@ -1,11 +1,11 @@ │ │ │ │ format in alloc::fmt - Rust
    │ │ │ │

    Function alloc::fmt::format

    1.0.0 · source · 
    pub fn format(args: Arguments<'_>) -> String
    Expand description

    The format function takes an Arguments struct and returns the resulting │ │ │ │ formatted string.

    │ │ │ │ -

    The Arguments instance can be created with the format_args! macro.

    │ │ │ │ +

    The Arguments instance can be created with the format_args! macro.

    │ │ │ │

    §Examples

    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  let s = fmt::format(format_args!("Hello, {}!", "world"));
│ │ │ │  assert_eq!(s, "Hello, world!");
    Run
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/fn.write.html │ │ │ │ @@ -1,22 +1,22 @@ │ │ │ │ write in alloc::fmt - Rust
    │ │ │ │ -

    Function alloc::fmt::write

    1.0.0 · source · 
    pub fn write(output: &mut dyn Write, args: Arguments<'_>) -> Result<(), Error>
    Expand description

    The write function takes an output stream, and an Arguments struct │ │ │ │ +

    Function alloc::fmt::write

    1.0.0 · source · 
    pub fn write(output: &mut dyn Write, args: Arguments<'_>) -> Result<(), Error>
    Expand description

    The write function takes an output stream, and an Arguments struct │ │ │ │ that can be precompiled with the format_args! macro.

    │ │ │ │

    The arguments will be formatted according to the specified format string │ │ │ │ into the output stream provided.

    │ │ │ │

    §Examples

    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  let mut output = String::new();
│ │ │ │  fmt::write(&mut output, format_args!("Hello {}!", "world"))
│ │ │ │      .expect("Error occurred while trying to write in String");
│ │ │ │  assert_eq!(output, "Hello world!");
    Run
    │ │ │ │ -

    Please note that using write! might be preferable. Example:

    │ │ │ │ +

    Please note that using write! might be preferable. Example:

    │ │ │ │ │ │ │ │ 
    use std::fmt::Write;
│ │ │ │  
│ │ │ │  let mut output = String::new();
│ │ │ │  write!(&mut output, "Hello {}!", "world")
│ │ │ │      .expect("Error occurred while trying to write in String");
│ │ │ │  assert_eq!(output, "Hello world!");
    Run
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/index.html │ │ │ │ @@ -85,17 +85,17 @@ │ │ │ │ println!("Hello {:width$}!", "x", width = 5); │ │ │ │ let width = 5; │ │ │ │ println!("Hello {:width$}!", "x");Run
    │ │ │ │

    This is a parameter for the “minimum width” that the format should take up. │ │ │ │ If the value’s string does not fill up this many characters, then the │ │ │ │ padding specified by fill/alignment will be used to take up the required │ │ │ │ space (see below).

    │ │ │ │ -

    The value for the width can also be provided as a usize in the list of │ │ │ │ +

    The value for the width can also be provided as a usize in the list of │ │ │ │ parameters by adding a postfix $, indicating that the second argument is │ │ │ │ -a usize specifying the width.

    │ │ │ │ +a usize specifying the width.

    │ │ │ │

    Referring to an argument with the dollar syntax does not affect the “next │ │ │ │ argument” counter, so it’s usually a good idea to refer to arguments by │ │ │ │ position, or use named arguments.

    │ │ │ │

    §Fill/Alignment

    │ │ │ │ 
    assert_eq!(format!("Hello {:<5}!", "x"),  "Hello x    !");
│ │ │ │  assert_eq!(format!("Hello {:-<5}!", "x"), "Hello x----!");
│ │ │ │  assert_eq!(format!("Hello {:^5}!", "x"),  "Hello   x  !");
│ │ │ │ @@ -275,24 +275,24 @@
│ │ │ │  type := '' | '?' | 'x?' | 'X?' | identifier
│ │ │ │  count := parameter | integer
│ │ │ │  parameter := argument '$'
│ │ │ │
    │ │ │ │

    In the above grammar,

    │ │ │ │
      │ │ │ │
    • text must not contain any '{' or '}' characters,
      • │ │ │ │ -
    • ws is any character for which char::is_whitespace returns true, has no semantic │ │ │ │ +
    • ws is any character for which char::is_whitespace returns true, has no semantic │ │ │ │ meaning and is completely optional,
      • │ │ │ │
    • integer is a decimal integer that may contain leading zeroes and must fit into an usize and
      • │ │ │ │
    • identifier is an IDENTIFIER_OR_KEYWORD (not an IDENTIFIER) as defined by the Rust language reference.
      • │ │ │ │
    │ │ │ │

    §Formatting traits

    │ │ │ │

    When requesting that an argument be formatted with a particular type, you │ │ │ │ are actually requesting that an argument ascribes to a particular trait. │ │ │ │ -This allows multiple actual types to be formatted via {:x} (like i8 as │ │ │ │ -well as isize). The current mapping of types to traits is:

    │ │ │ │ +This allows multiple actual types to be formatted via {:x} (like i8 as │ │ │ │ +well as isize). The current mapping of types to traits is:

    │ │ │ │
      │ │ │ │
    • nothing ⇒ Display
      • │ │ │ │
    • ? ⇒ Debug
      • │ │ │ │
    • x? ⇒ Debug with lower-case hexadecimal integers
      • │ │ │ │
    • X? ⇒ Debug with upper-case hexadecimal integers
      • │ │ │ │
    • o ⇒ Octal
      • │ │ │ │
    • x ⇒ LowerHex
      • │ │ │ │ @@ -314,17 +314,17 @@ │ │ │ │

      Your type will be passed as self by-reference, and then the function │ │ │ │ should emit output into the Formatter f which implements fmt::Write. It is up to each │ │ │ │ format trait implementation to correctly adhere to the requested formatting parameters. │ │ │ │ The values of these parameters can be accessed with methods of the │ │ │ │ Formatter struct. In order to help with this, the Formatter struct also │ │ │ │ provides some helper methods.

      │ │ │ │

      Additionally, the return value of this function is fmt::Result which is a │ │ │ │ -type alias of Result<(), std::fmt::Error>. Formatting implementations │ │ │ │ +type alias of Result<(), std::fmt::Error>. Formatting implementations │ │ │ │ should ensure that they propagate errors from the Formatter (e.g., when │ │ │ │ -calling write!). However, they should never return errors spuriously. That │ │ │ │ +calling write!). However, they should never return errors spuriously. That │ │ │ │ is, a formatting implementation must and may only return an error if the │ │ │ │ passed-in Formatter returns an error. This is because, contrary to what │ │ │ │ the function signature might suggest, string formatting is an infallible │ │ │ │ operation. This function only returns a result because writing to the │ │ │ │ underlying stream might fail and it must provide a way to propagate the fact │ │ │ │ that an error has occurred back up the stack.

      │ │ │ │

      An example of implementing the formatting traits would look │ │ │ │ @@ -396,25 +396,25 @@ │ │ │ │ writeln! // same as write but appends a newline │ │ │ │ print! // the format string is printed to the standard output │ │ │ │ println! // same as print but appends a newline │ │ │ │ eprint! // the format string is printed to the standard error │ │ │ │ eprintln! // same as eprint but appends a newline │ │ │ │ format_args! // described below.Run

    │ │ │ │

    §write!

    │ │ │ │ -

    write! and writeln! are two macros which are used to emit the format string │ │ │ │ +

    write! and writeln! are two macros which are used to emit the format string │ │ │ │ to a specified stream. This is used to prevent intermediate allocations of │ │ │ │ format strings and instead directly write the output. Under the hood, this │ │ │ │ function is actually invoking the write_fmt function defined on the │ │ │ │ std::io::Write and the std::fmt::Write trait. Example usage is:

    │ │ │ │ │ │ │ │ 
    use std::io::Write;
│ │ │ │  let mut w = Vec::new();
│ │ │ │  write!(&mut w, "Hello {}!", "world");
    Run
    │ │ │ │

    §print!

    │ │ │ │ -

    This and println! emit their output to stdout. Similarly to the write! │ │ │ │ +

    This and println! emit their output to stdout. Similarly to the write! │ │ │ │ macro, the goal of these macros is to avoid intermediate allocations when │ │ │ │ printing output. Example usage is:

    │ │ │ │ │ │ │ │ 
    print!("Hello {}!", "world");
│ │ │ │  println!("I have a newline {}", "character at the end");
    Run
    │ │ │ │

    §eprint!

    │ │ │ │

    The eprint! and eprintln! macros are identical to │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.Arguments.html │ │ │ │ @@ -1,25 +1,25 @@ │ │ │ │ Arguments in alloc::fmt - Rust

    │ │ │ │ -

    Struct alloc::fmt::Arguments

    1.0.0 · source · 
    pub struct Arguments<'a> { /* private fields */ }
    Expand description

    This structure represents a safely precompiled version of a format string │ │ │ │ +

    Struct alloc::fmt::Arguments

    1.0.0 · source · 
    pub struct Arguments<'a> { /* private fields */ }
    Expand description

    This structure represents a safely precompiled version of a format string │ │ │ │ and its arguments. This cannot be generated at runtime because it cannot │ │ │ │ safely be done, so no constructors are given and the fields are private │ │ │ │ to prevent modification.

    │ │ │ │ -

    The format_args! macro will safely create an instance of this structure. │ │ │ │ +

    The format_args! macro will safely create an instance of this structure. │ │ │ │ The macro validates the format string at compile-time so usage of the │ │ │ │ write() and format() functions can be safely performed.

    │ │ │ │ -

    You can use the Arguments<'a> that format_args! returns in Debug │ │ │ │ +

    You can use the Arguments<'a> that format_args! returns in Debug │ │ │ │ and Display contexts as seen below. The example also shows that Debug │ │ │ │ and Display format to the same thing: the interpolated format string │ │ │ │ in format_args!.

    │ │ │ │ │ │ │ │ 
    let debug = format!("{:?}", format_args!("{} foo {:?}", 1, 2));
│ │ │ │  let display = format!("{}", format_args!("{} foo {:?}", 1, 2));
│ │ │ │  assert_eq!("1 foo 2", display);
│ │ │ │  assert_eq!(display, debug);
    Run
    │ │ │ │ -

    Implementations§

    source§

    impl<'a> Arguments<'a>

    1.52.0 (const: unstable) · source

    pub fn as_str(&self) -> Option<&'static str>

    Get the formatted string, if it has no arguments to be formatted at runtime.

    │ │ │ │ +

    Implementations§

    source§

    impl<'a> Arguments<'a>

    1.52.0 (const: unstable) · source

    pub fn as_str(&self) -> Option<&'static str>

    Get the formatted string, if it has no arguments to be formatted at runtime.

    │ │ │ │

    This can be used to avoid allocations in some cases.

    │ │ │ │
    §Guarantees
    │ │ │ │

    For format_args!("just a literal"), this function is guaranteed to │ │ │ │ return Some("just a literal").

    │ │ │ │

    For most cases with placeholders, this function will return None.

    │ │ │ │

    However, the compiler may perform optimizations that can cause this │ │ │ │ function to return Some(_) even if the format string contains │ │ │ │ @@ -41,20 +41,20 @@ │ │ │ │ write_str(&args.to_string()); │ │ │ │ } │ │ │ │ }Run

    │ │ │ │ │ │ │ │ 
    assert_eq!(format_args!("hello").as_str(), Some("hello"));
│ │ │ │  assert_eq!(format_args!("").as_str(), Some(""));
│ │ │ │  assert_eq!(format_args!("{:?}", std::env::current_dir()).as_str(), None);
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<'a> Clone for Arguments<'a>

    source§

    fn clone(&self) -> Arguments<'a>

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for Arguments<'_>

    source§

    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl Display for Arguments<'_>

    source§

    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a> Copy for Arguments<'a>

    Auto Trait Implementations§

    §

    impl<'a> Freeze for Arguments<'a>

    §

    impl<'a> !RefUnwindSafe for Arguments<'a>

    §

    impl<'a> !Send for Arguments<'a>

    §

    impl<'a> !Sync for Arguments<'a>

    §

    impl<'a> Unpin for Arguments<'a>

    §

    impl<'a> !UnwindSafe for Arguments<'a>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<'a> Clone for Arguments<'a>

    source§

    fn clone(&self) -> Arguments<'a>

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for Arguments<'_>

    source§

    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl Display for Arguments<'_>

    source§

    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a> Copy for Arguments<'a>

    Auto Trait Implementations§

    §

    impl<'a> Freeze for Arguments<'a>

    §

    impl<'a> !RefUnwindSafe for Arguments<'a>

    §

    impl<'a> !Send for Arguments<'a>

    §

    impl<'a> !Sync for Arguments<'a>

    §

    impl<'a> Unpin for Arguments<'a>

    §

    impl<'a> !UnwindSafe for Arguments<'a>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugList.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ DebugList in alloc::fmt - Rust
    │ │ │ │ -

    Struct alloc::fmt::DebugList

    1.2.0 · source · 
    pub struct DebugList<'a, 'b>
    where
│ │ │ │ +    
    Struct alloc::fmt::DebugList
    1.2.0 · source · 
    pub struct DebugList<'a, 'b>
    where
│ │ │ │      'b: 'a,
    { /* private fields */ }
    Expand description
    A struct to help with fmt::Debug implementations.
    
│ │ │ │  
    This is useful when you wish to output a formatted list of items as a part
│ │ │ │  of your Debug::fmt implementation.
    
│ │ │ │  
    This can be constructed by the Formatter::debug_list method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │ @@ -15,16 +15,16 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![10, 11])),
│ │ │ │      "[10, 11]",
│ │ │ │  );
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, 'b> DebugList<'a, 'b>
    where
│ │ │ │ -    'b: 'a,
    source
    pub fn entry(&mut self, entry: &dyn Debug) -> &mut DebugList<'a, 'b>
    Adds a new entry to the list output.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, 'b> DebugList<'a, 'b>
    where
│ │ │ │ +    'b: 'a,
    source
    pub fn entry(&mut self, entry: &dyn Debug) -> &mut DebugList<'a, 'b>
    Adds a new entry to the list output.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(Vec<i32>, Vec<u32>);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -35,21 +35,21 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![10, 11], vec![12, 13])),
│ │ │ │      "[[10, 11], [12, 13]]",
│ │ │ │  );
    Run
    
│ │ │ │ -
    source
    pub fn entry_with<F>(&mut self, entry_fmt: F) -> &mut DebugList<'a, 'b>
    where
│ │ │ │ -    F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)
    Adds a new entry to the list output.
    
│ │ │ │ +
    source
    pub fn entry_with<F>(&mut self, entry_fmt: F) -> &mut DebugList<'a, 'b>
    where
│ │ │ │ +    F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)
    Adds a new entry to the list output.
    
│ │ │ │  
    This method is equivalent to DebugList::entry, but formats the
│ │ │ │  entry using a provided closure rather than by calling Debug::fmt.
    
│ │ │ │ -
    source
    pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugList<'a, 'b>
    where
│ │ │ │ +
    source
    pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugList<'a, 'b>
    where
│ │ │ │      D: Debug,
│ │ │ │ -    I: IntoIterator<Item = D>,
    Adds the contents of an iterator of entries to the list output.
    
│ │ │ │ +    I: IntoIterator<Item = D>,
    Adds the contents of an iterator of entries to the list output.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(Vec<i32>, Vec<u32>);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -60,15 +60,15 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![10, 11], vec![12, 13])),
│ │ │ │      "[10, 11, 12, 13]",
│ │ │ │  );
    Run
    
│ │ │ │ -
    source
    pub fn finish(&mut self) -> Result<(), Error>
    Finishes output and returns any error encountered.
    
│ │ │ │ +
    source
    pub fn finish(&mut self) -> Result<(), Error>
    Finishes output and returns any error encountered.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(Vec<i32>);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -78,18 +78,18 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![10, 11])),
│ │ │ │      "[10, 11]",
│ │ │ │  );
    Run
    
│ │ │ │ -
    Auto Trait Implementations§
    §
    impl<'a, 'b> Freeze for DebugList<'a, 'b>
    §
    impl<'a, 'b> !RefUnwindSafe for DebugList<'a, 'b>
    §
    impl<'a, 'b> !Send for DebugList<'a, 'b>
    §
    impl<'a, 'b> !Sync for DebugList<'a, 'b>
    §
    impl<'a, 'b> Unpin for DebugList<'a, 'b>
    §
    impl<'a, 'b> !UnwindSafe for DebugList<'a, 'b>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    Auto Trait Implementations§
    §
    impl<'a, 'b> Freeze for DebugList<'a, 'b>
    §
    impl<'a, 'b> !RefUnwindSafe for DebugList<'a, 'b>
    §
    impl<'a, 'b> !Send for DebugList<'a, 'b>
    §
    impl<'a, 'b> !Sync for DebugList<'a, 'b>
    §
    impl<'a, 'b> Unpin for DebugList<'a, 'b>
    §
    impl<'a, 'b> !UnwindSafe for DebugList<'a, 'b>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugMap.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ DebugMap in alloc::fmt - Rust
    │ │ │ │ -

    Struct alloc::fmt::DebugMap

    1.2.0 · source · 
    pub struct DebugMap<'a, 'b>
    where
│ │ │ │ +    
    Struct alloc::fmt::DebugMap
    1.2.0 · source · 
    pub struct DebugMap<'a, 'b>
    where
│ │ │ │      'b: 'a,
    { /* private fields */ }
    Expand description
    A struct to help with fmt::Debug implementations.
    
│ │ │ │  
    This is useful when you wish to output a formatted map as a part of your
│ │ │ │  Debug::fmt implementation.
    
│ │ │ │  
    This can be constructed by the Formatter::debug_map method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │ @@ -15,16 +15,16 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
│ │ │ │      "{\"A\": 10, \"B\": 11}",
│ │ │ │  );
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, 'b> DebugMap<'a, 'b>
    where
│ │ │ │ -    'b: 'a,
    source
    pub fn entry(
│ │ │ │ +
    Implementations§
    source§
    impl<'a, 'b> DebugMap<'a, 'b>
    where
│ │ │ │ +    'b: 'a,
    source
    pub fn entry(
│ │ │ │      &mut self,
│ │ │ │      key: &dyn Debug,
│ │ │ │      value: &dyn Debug
│ │ │ │  ) -> &mut DebugMap<'a, 'b>
    Adds a new entry to the map output.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │ @@ -38,15 +38,15 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
│ │ │ │      "{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
│ │ │ │  );
    Run
    
│ │ │ │ -
    1.42.0 · source
    pub fn key(&mut self, key: &dyn Debug) -> &mut DebugMap<'a, 'b>
    Adds the key part of a new entry to the map output.
    
│ │ │ │ +
    1.42.0 · source
    pub fn key(&mut self, key: &dyn Debug) -> &mut DebugMap<'a, 'b>
    Adds the key part of a new entry to the map output.
    
│ │ │ │  
    This method, together with value, is an alternative to entry that
│ │ │ │  can be used when the complete entry isn’t known upfront. Prefer the entry
│ │ │ │  method when it’s possible to use.
    
│ │ │ │  
    §Panics
    
│ │ │ │  
    key must be called before value and each call to key must be followed
│ │ │ │  by a corresponding call to value. Otherwise this method will panic.
    
│ │ │ │  
    §Examples
    
│ │ │ │ @@ -62,19 +62,19 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
│ │ │ │      "{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
│ │ │ │  );
    Run
    │ │ │ │ -
    source

    pub fn key_with<F>(&mut self, key_fmt: F) -> &mut DebugMap<'a, 'b>
    where │ │ │ │ - F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,

    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)

    Adds the key part of a new entry to the map output.

    │ │ │ │ +
    source

    pub fn key_with<F>(&mut self, key_fmt: F) -> &mut DebugMap<'a, 'b>
    where │ │ │ │ + F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,

    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)

    Adds the key part of a new entry to the map output.

    │ │ │ │

    This method is equivalent to DebugMap::key, but formats the │ │ │ │ key using a provided closure rather than by calling Debug::fmt.

    │ │ │ │ -
    1.42.0 · source

    pub fn value(&mut self, value: &dyn Debug) -> &mut DebugMap<'a, 'b>

    Adds the value part of a new entry to the map output.

    │ │ │ │ +
    1.42.0 · source

    pub fn value(&mut self, value: &dyn Debug) -> &mut DebugMap<'a, 'b>

    Adds the value part of a new entry to the map output.

    │ │ │ │

    This method, together with key, is an alternative to entry that │ │ │ │ can be used when the complete entry isn’t known upfront. Prefer the entry │ │ │ │ method when it’s possible to use.

    │ │ │ │
    §Panics
    │ │ │ │

    key must be called before value and each call to key must be followed │ │ │ │ by a corresponding call to value. Otherwise this method will panic.

    │ │ │ │
    §Examples
    │ │ │ │ @@ -90,22 +90,22 @@ │ │ │ │ } │ │ │ │ } │ │ │ │ │ │ │ │ assert_eq!( │ │ │ │ format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])), │ │ │ │ "{\"whole\": [(\"A\", 10), (\"B\", 11)]}", │ │ │ │ );    Run
    │ │ │ │ -
    source

    pub fn value_with<F>(&mut self, value_fmt: F) -> &mut DebugMap<'a, 'b>
    where │ │ │ │ - F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,

    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)

    Adds the value part of a new entry to the map output.

    │ │ │ │ +
    source

    pub fn value_with<F>(&mut self, value_fmt: F) -> &mut DebugMap<'a, 'b>
    where │ │ │ │ + F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,

    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)

    Adds the value part of a new entry to the map output.

    │ │ │ │

    This method is equivalent to DebugMap::value, but formats the │ │ │ │ value using a provided closure rather than by calling Debug::fmt.

    │ │ │ │ -
    source

    pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
    where │ │ │ │ +

    source

    pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
    where │ │ │ │ K: Debug, │ │ │ │ V: Debug, │ │ │ │ - I: IntoIterator<Item = (K, V)>,

    Adds the contents of an iterator of entries to the map output.

    │ │ │ │ + I: IntoIterator<Item = (K, V)>,

    Adds the contents of an iterator of entries to the map output.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(Vec<(String, i32)>);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -117,15 +117,15 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
│ │ │ │      "{\"A\": 10, \"B\": 11}",
│ │ │ │  );
    Run
    │ │ │ │ -
    source

    pub fn finish(&mut self) -> Result<(), Error>

    Finishes output and returns any error encountered.

    │ │ │ │ +
    source

    pub fn finish(&mut self) -> Result<(), Error>

    Finishes output and returns any error encountered.

    │ │ │ │
    §Panics
    │ │ │ │

    key must be called before value and each call to key must be followed │ │ │ │ by a corresponding call to value. Otherwise this method will panic.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(Vec<(String, i32)>);
│ │ │ │ @@ -138,18 +138,18 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
│ │ │ │      "{\"A\": 10, \"B\": 11}",
│ │ │ │  );
    Run
    │ │ │ │ -

    Auto Trait Implementations§

    §

    impl<'a, 'b> Freeze for DebugMap<'a, 'b>

    §

    impl<'a, 'b> !RefUnwindSafe for DebugMap<'a, 'b>

    §

    impl<'a, 'b> !Send for DebugMap<'a, 'b>

    §

    impl<'a, 'b> !Sync for DebugMap<'a, 'b>

    §

    impl<'a, 'b> Unpin for DebugMap<'a, 'b>

    §

    impl<'a, 'b> !UnwindSafe for DebugMap<'a, 'b>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Auto Trait Implementations§

    §

    impl<'a, 'b> Freeze for DebugMap<'a, 'b>

    §

    impl<'a, 'b> !RefUnwindSafe for DebugMap<'a, 'b>

    §

    impl<'a, 'b> !Send for DebugMap<'a, 'b>

    §

    impl<'a, 'b> !Sync for DebugMap<'a, 'b>

    §

    impl<'a, 'b> Unpin for DebugMap<'a, 'b>

    §

    impl<'a, 'b> !UnwindSafe for DebugMap<'a, 'b>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugSet.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ DebugSet in alloc::fmt - Rust
    │ │ │ │ -

    Struct alloc::fmt::DebugSet

    1.2.0 · source · 
    pub struct DebugSet<'a, 'b>
    where
│ │ │ │ +    
    Struct alloc::fmt::DebugSet
    1.2.0 · source · 
    pub struct DebugSet<'a, 'b>
    where
│ │ │ │      'b: 'a,
    { /* private fields */ }
    Expand description
    A struct to help with fmt::Debug implementations.
    
│ │ │ │  
    This is useful when you wish to output a formatted set of items as a part
│ │ │ │  of your Debug::fmt implementation.
    
│ │ │ │  
    This can be constructed by the Formatter::debug_set method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │ @@ -15,16 +15,16 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![10, 11])),
│ │ │ │      "{10, 11}",
│ │ │ │  );
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, 'b> DebugSet<'a, 'b>
    where
│ │ │ │ -    'b: 'a,
    source
    pub fn entry(&mut self, entry: &dyn Debug) -> &mut DebugSet<'a, 'b>
    Adds a new entry to the set output.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, 'b> DebugSet<'a, 'b>
    where
│ │ │ │ +    'b: 'a,
    source
    pub fn entry(&mut self, entry: &dyn Debug) -> &mut DebugSet<'a, 'b>
    Adds a new entry to the set output.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(Vec<i32>, Vec<u32>);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -35,21 +35,21 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![10, 11], vec![12, 13])),
│ │ │ │      "{[10, 11], [12, 13]}",
│ │ │ │  );
    Run
    
│ │ │ │ -
    source
    pub fn entry_with<F>(&mut self, entry_fmt: F) -> &mut DebugSet<'a, 'b>
    where
│ │ │ │ -    F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)
    Adds a new entry to the set output.
    
│ │ │ │ +
    source
    pub fn entry_with<F>(&mut self, entry_fmt: F) -> &mut DebugSet<'a, 'b>
    where
│ │ │ │ +    F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)
    Adds a new entry to the set output.
    
│ │ │ │  
    This method is equivalent to DebugSet::entry, but formats the
│ │ │ │  entry using a provided closure rather than by calling Debug::fmt.
    
│ │ │ │ -
    source
    pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugSet<'a, 'b>
    where
│ │ │ │ +
    source
    pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugSet<'a, 'b>
    where
│ │ │ │      D: Debug,
│ │ │ │ -    I: IntoIterator<Item = D>,
    Adds the contents of an iterator of entries to the set output.
    
│ │ │ │ +    I: IntoIterator<Item = D>,
    Adds the contents of an iterator of entries to the set output.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(Vec<i32>, Vec<u32>);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -60,15 +60,15 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![10, 11], vec![12, 13])),
│ │ │ │      "{10, 11, 12, 13}",
│ │ │ │  );
    Run
    
│ │ │ │ -
    source
    pub fn finish(&mut self) -> Result<(), Error>
    Finishes output and returns any error encountered.
    
│ │ │ │ +
    source
    pub fn finish(&mut self) -> Result<(), Error>
    Finishes output and returns any error encountered.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(Vec<i32>);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -78,18 +78,18 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(vec![10, 11])),
│ │ │ │      "{10, 11}",
│ │ │ │  );
    Run
    
│ │ │ │ -
    Auto Trait Implementations§
    §
    impl<'a, 'b> Freeze for DebugSet<'a, 'b>
    §
    impl<'a, 'b> !RefUnwindSafe for DebugSet<'a, 'b>
    §
    impl<'a, 'b> !Send for DebugSet<'a, 'b>
    §
    impl<'a, 'b> !Sync for DebugSet<'a, 'b>
    §
    impl<'a, 'b> Unpin for DebugSet<'a, 'b>
    §
    impl<'a, 'b> !UnwindSafe for DebugSet<'a, 'b>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    Auto Trait Implementations§
    §
    impl<'a, 'b> Freeze for DebugSet<'a, 'b>
    §
    impl<'a, 'b> !RefUnwindSafe for DebugSet<'a, 'b>
    §
    impl<'a, 'b> !Send for DebugSet<'a, 'b>
    §
    impl<'a, 'b> !Sync for DebugSet<'a, 'b>
    §
    impl<'a, 'b> Unpin for DebugSet<'a, 'b>
    §
    impl<'a, 'b> !UnwindSafe for DebugSet<'a, 'b>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugStruct.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ DebugStruct in alloc::fmt - Rust
    │ │ │ │ -

    Struct alloc::fmt::DebugStruct

    1.2.0 · source · 
    pub struct DebugStruct<'a, 'b>
    where
│ │ │ │ +    
    Struct alloc::fmt::DebugStruct
    1.2.0 · source · 
    pub struct DebugStruct<'a, 'b>
    where
│ │ │ │      'b: 'a,
    { /* private fields */ }
    Expand description
    A struct to help with fmt::Debug implementations.
    
│ │ │ │  
    This is useful when you wish to output a formatted struct as a part of your
│ │ │ │  Debug::fmt implementation.
    
│ │ │ │  
    This can be constructed by the Formatter::debug_struct method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │ @@ -21,18 +21,18 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo { bar: 10, baz: "Hello World".to_string() }),
│ │ │ │      "Foo { bar: 10, baz: \"Hello World\" }",
│ │ │ │  );
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, 'b> DebugStruct<'a, 'b>
    where
│ │ │ │ -    'b: 'a,
    source
    pub fn field(
│ │ │ │ +
    Implementations§
    source§
    impl<'a, 'b> DebugStruct<'a, 'b>
    where
│ │ │ │ +    'b: 'a,
    source
    pub fn field(
│ │ │ │      &mut self,
│ │ │ │ -    name: &str,
│ │ │ │ +    name: &str,
│ │ │ │      value: &dyn Debug
│ │ │ │  ) -> &mut DebugStruct<'a, 'b>
    Adds a new field to the generated struct output.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Bar {
│ │ │ │      bar: i32,
│ │ │ │ @@ -50,23 +50,23 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Bar { bar: 10, another: "Hello World".to_string() }),
│ │ │ │      "Bar { bar: 10, another: \"Hello World\", nonexistent_field: 1 }",
│ │ │ │  );
    Run
    
│ │ │ │ -
    source
    pub fn field_with<F>(
│ │ │ │ +
    source
    pub fn field_with<F>(
│ │ │ │      &mut self,
│ │ │ │ -    name: &str,
│ │ │ │ +    name: &str,
│ │ │ │      value_fmt: F
│ │ │ │  ) -> &mut DebugStruct<'a, 'b>
    where
│ │ │ │ -    F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)
    Adds a new field to the generated struct output.
    
│ │ │ │ +    F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)
    Adds a new field to the generated struct output.
    
│ │ │ │  
    This method is equivalent to DebugStruct::field, but formats the
│ │ │ │  value using a provided closure rather than by calling Debug::fmt.
    
│ │ │ │ -
    1.53.0 · source
    pub fn finish_non_exhaustive(&mut self) -> Result<(), Error>
    Marks the struct as non-exhaustive, indicating to the reader that there are some other
│ │ │ │ +
    1.53.0 · source
    pub fn finish_non_exhaustive(&mut self) -> Result<(), Error>
    Marks the struct as non-exhaustive, indicating to the reader that there are some other
│ │ │ │  fields that are not shown in the debug representation.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Bar {
│ │ │ │      bar: i32,
│ │ │ │      hidden: f32,
│ │ │ │ @@ -80,15 +80,15 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Bar { bar: 10, hidden: 1.0 }),
│ │ │ │      "Bar { bar: 10, .. }",
│ │ │ │  );
    Run
    
│ │ │ │ -
    source
    pub fn finish(&mut self) -> Result<(), Error>
    Finishes output and returns any error encountered.
    
│ │ │ │ +
    source
    pub fn finish(&mut self) -> Result<(), Error>
    Finishes output and returns any error encountered.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Bar {
│ │ │ │      bar: i32,
│ │ │ │      baz: String,
│ │ │ │  }
│ │ │ │ @@ -103,18 +103,18 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Bar { bar: 10, baz: "Hello World".to_string() }),
│ │ │ │      "Bar { bar: 10, baz: \"Hello World\" }",
│ │ │ │  );
    Run
    
│ │ │ │ -
    Auto Trait Implementations§
    §
    impl<'a, 'b> Freeze for DebugStruct<'a, 'b>
    §
    impl<'a, 'b> !RefUnwindSafe for DebugStruct<'a, 'b>
    §
    impl<'a, 'b> !Send for DebugStruct<'a, 'b>
    §
    impl<'a, 'b> !Sync for DebugStruct<'a, 'b>
    §
    impl<'a, 'b> Unpin for DebugStruct<'a, 'b>
    §
    impl<'a, 'b> !UnwindSafe for DebugStruct<'a, 'b>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    Auto Trait Implementations§
    §
    impl<'a, 'b> Freeze for DebugStruct<'a, 'b>
    §
    impl<'a, 'b> !RefUnwindSafe for DebugStruct<'a, 'b>
    §
    impl<'a, 'b> !Send for DebugStruct<'a, 'b>
    §
    impl<'a, 'b> !Sync for DebugStruct<'a, 'b>
    §
    impl<'a, 'b> Unpin for DebugStruct<'a, 'b>
    §
    impl<'a, 'b> !UnwindSafe for DebugStruct<'a, 'b>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.DebugTuple.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ DebugTuple in alloc::fmt - Rust
    │ │ │ │ -

    Struct alloc::fmt::DebugTuple

    1.2.0 · source · 
    pub struct DebugTuple<'a, 'b>
    where
│ │ │ │ +    
    Struct alloc::fmt::DebugTuple
    1.2.0 · source · 
    pub struct DebugTuple<'a, 'b>
    where
│ │ │ │      'b: 'a,
    { /* private fields */ }
    Expand description
    A struct to help with fmt::Debug implementations.
    
│ │ │ │  
    This is useful when you wish to output a formatted tuple as a part of your
│ │ │ │  Debug::fmt implementation.
    
│ │ │ │  
    This can be constructed by the Formatter::debug_tuple method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │ @@ -18,16 +18,16 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(10, "Hello World".to_string())),
│ │ │ │      "Foo(10, \"Hello World\")",
│ │ │ │  );
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, 'b> DebugTuple<'a, 'b>
    where
│ │ │ │ -    'b: 'a,
    source
    pub fn field(&mut self, value: &dyn Debug) -> &mut DebugTuple<'a, 'b>
    Adds a new field to the generated tuple struct output.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, 'b> DebugTuple<'a, 'b>
    where
│ │ │ │ +    'b: 'a,
    source
    pub fn field(&mut self, value: &dyn Debug) -> &mut DebugTuple<'a, 'b>
    Adds a new field to the generated tuple struct output.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(i32, String);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -38,19 +38,19 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(10, "Hello World".to_string())),
│ │ │ │      "Foo(10, \"Hello World\")",
│ │ │ │  );
    Run
    
│ │ │ │ -
    source
    pub fn field_with<F>(&mut self, value_fmt: F) -> &mut DebugTuple<'a, 'b>
    where
│ │ │ │ -    F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)
    Adds a new field to the generated tuple struct output.
    
│ │ │ │ +
    source
    pub fn field_with<F>(&mut self, value_fmt: F) -> &mut DebugTuple<'a, 'b>
    where
│ │ │ │ +    F: FnOnce(&mut Formatter<'_>) -> Result<(), Error>,
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)
    Adds a new field to the generated tuple struct output.
    
│ │ │ │  
    This method is equivalent to DebugTuple::field, but formats the
│ │ │ │  value using a provided closure rather than by calling Debug::fmt.
    
│ │ │ │ -
    source
    pub fn finish(&mut self) -> Result<(), Error>
    Finishes output and returns any error encountered.
    
│ │ │ │ +
    source
    pub fn finish(&mut self) -> Result<(), Error>
    Finishes output and returns any error encountered.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(i32, String);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -62,18 +62,18 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}", Foo(10, "Hello World".to_string())),
│ │ │ │      "Foo(10, \"Hello World\")",
│ │ │ │  );
    Run
    
│ │ │ │ -
    Auto Trait Implementations§
    §
    impl<'a, 'b> Freeze for DebugTuple<'a, 'b>
    §
    impl<'a, 'b> !RefUnwindSafe for DebugTuple<'a, 'b>
    §
    impl<'a, 'b> !Send for DebugTuple<'a, 'b>
    §
    impl<'a, 'b> !Sync for DebugTuple<'a, 'b>
    §
    impl<'a, 'b> Unpin for DebugTuple<'a, 'b>
    §
    impl<'a, 'b> !UnwindSafe for DebugTuple<'a, 'b>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    Auto Trait Implementations§
    §
    impl<'a, 'b> Freeze for DebugTuple<'a, 'b>
    §
    impl<'a, 'b> !RefUnwindSafe for DebugTuple<'a, 'b>
    §
    impl<'a, 'b> !Send for DebugTuple<'a, 'b>
    §
    impl<'a, 'b> !Sync for DebugTuple<'a, 'b>
    §
    impl<'a, 'b> Unpin for DebugTuple<'a, 'b>
    §
    impl<'a, 'b> !UnwindSafe for DebugTuple<'a, 'b>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.Error.html │ │ │ │ @@ -1,38 +1,38 @@ │ │ │ │ Error in alloc::fmt - Rust
    │ │ │ │ -

    Struct alloc::fmt::Error

    1.0.0 · source · 
    pub struct Error;
    Expand description

    The error type which is returned from formatting a message into a stream.

    │ │ │ │ +

    Struct alloc::fmt::Error

    1.0.0 · source · 
    pub struct Error;
    Expand description

    The error type which is returned from formatting a message into a stream.

    │ │ │ │

    This type does not support transmission of an error other than that an error │ │ │ │ occurred. Any extra information must be arranged to be transmitted through │ │ │ │ some other means.

    │ │ │ │

    An important thing to remember is that the type fmt::Error should not be │ │ │ │ confused with std::io::Error or std::error::Error, which you may also │ │ │ │ have in scope.

    │ │ │ │

    §Examples

    │ │ │ │ 
    use std::fmt::{self, write};
│ │ │ │  
│ │ │ │  let mut output = String::new();
│ │ │ │  if let Err(fmt::Error) = write(&mut output, format_args!("Hello {}!", "world")) {
│ │ │ │      panic!("An error occurred");
│ │ │ │  }
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl Clone for Error

    source§

    fn clone(&self) -> Error

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for Error

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl Default for Error

    source§

    fn default() -> Error

    Returns the “default value” for a type. Read more
    source§

    impl Display for Error

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    1.11.0 · source§

    impl Error for Error

    source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.30.0 · source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl Hash for Error

    source§

    fn hash<__H>(&self, state: &mut __H)
    where │ │ │ │ - __H: Hasher,

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ - H: Hasher, │ │ │ │ - Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl Ord for Error

    source§

    fn cmp(&self, other: &Error) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ - Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq for Error

    source§

    fn eq(&self, other: &Error) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ -by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd for Error

    source§

    fn partial_cmp(&self, other: &Error) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ -operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ -operator. Read more
    source§

    impl Copy for Error

    source§

    impl Eq for Error

    source§

    impl StructuralPartialEq for Error

    Auto Trait Implementations§

    §

    impl Freeze for Error

    §

    impl RefUnwindSafe for Error

    §

    impl Send for Error

    §

    impl Sync for Error

    §

    impl Unpin for Error

    §

    impl UnwindSafe for Error

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl Clone for Error

    source§

    fn clone(&self) -> Error

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for Error

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl Default for Error

    source§

    fn default() -> Error

    Returns the “default value” for a type. Read more
    source§

    impl Display for Error

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    1.11.0 · source§

    impl Error for Error

    source§

    fn description(&self) -> &str

    👎Deprecated since 1.42.0: use the Display impl or to_string()
    Read more
    1.30.0 · source§

    fn source(&self) -> Option<&(dyn Error + 'static)>

    The lower-level source of this error, if any. Read more
    source§

    fn cause(&self) -> Option<&dyn Error>

    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§

    fn provide<'a>(&'a self, request: &mut Request<'a>)

    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§

    impl Hash for Error

    source§

    fn hash<__H>(&self, state: &mut __H)
    where │ │ │ │ + __H: Hasher,

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ + H: Hasher, │ │ │ │ + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl Ord for Error

    source§

    fn cmp(&self, other: &Error) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ + Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq for Error

    source§

    fn eq(&self, other: &Error) -> bool

    This method tests for self and other values to be equal, and is used │ │ │ │ +by ==.
    source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always │ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd for Error

    source§

    fn partial_cmp(&self, other: &Error) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= │ │ │ │ +operator. Read more
    source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= │ │ │ │ +operator. Read more
    source§

    impl Copy for Error

    source§

    impl Eq for Error

    source§

    impl StructuralPartialEq for Error

    Auto Trait Implementations§

    §

    impl Freeze for Error

    §

    impl RefUnwindSafe for Error

    §

    impl Send for Error

    §

    impl Sync for Error

    §

    impl Unpin for Error

    §

    impl UnwindSafe for Error

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.Formatter.html │ │ │ │ @@ -1,21 +1,21 @@ │ │ │ │ Formatter in alloc::fmt - Rust
    │ │ │ │ -

    Struct alloc::fmt::Formatter

    1.0.0 · source · 
    pub struct Formatter<'a> { /* private fields */ }
    Expand description

    Configuration for formatting.

    │ │ │ │ +

    Struct alloc::fmt::Formatter

    1.0.0 · source · 
    pub struct Formatter<'a> { /* private fields */ }
    Expand description

    Configuration for formatting.

    │ │ │ │

    A Formatter represents various options related to formatting. Users do not │ │ │ │ construct Formatters directly; a mutable reference to one is passed to │ │ │ │ the fmt method of all formatting traits, like Debug and Display.

    │ │ │ │

    To interact with a Formatter, you’ll call various methods to change the │ │ │ │ various options related to formatting. For examples, please see the │ │ │ │ documentation of the methods defined on Formatter below.

    │ │ │ │ -

    Implementations§

    source§

    impl<'a> Formatter<'a>

    source

    pub fn pad_integral( │ │ │ │ +

    Implementations§

    source§

    impl<'a> Formatter<'a>

    source

    pub fn pad_integral( │ │ │ │ &mut self, │ │ │ │ - is_nonnegative: bool, │ │ │ │ - prefix: &str, │ │ │ │ - buf: &str │ │ │ │ -) -> Result<(), Error>

    Performs the correct padding for an integer which has already been │ │ │ │ + is_nonnegative: bool, │ │ │ │ + prefix: &str, │ │ │ │ + buf: &str │ │ │ │ +) -> Result<(), Error>

    Performs the correct padding for an integer which has already been │ │ │ │ emitted into a str. The str should not contain the sign for the │ │ │ │ integer, that will be added by this method.

    │ │ │ │
    §Arguments
    │ │ │ │
      │ │ │ │
    • is_nonnegative - whether the original integer was either positive or zero.
      • │ │ │ │
    • prefix - if the ‘#’ character (Alternate) is provided, this │ │ │ │ is the prefix to put in front of the number.
      • │ │ │ │ @@ -46,15 +46,15 @@ │ │ │ │ } │ │ │ │ │ │ │ │ assert_eq!(format!("{}", Foo::new(2)), "2"); │ │ │ │ assert_eq!(format!("{}", Foo::new(-1)), "-1"); │ │ │ │ assert_eq!(format!("{}", Foo::new(0)), "0"); │ │ │ │ assert_eq!(format!("{:#}", Foo::new(-1)), "-Foo 1"); │ │ │ │ assert_eq!(format!("{:0>#8}", Foo::new(-1)), "00-Foo 1");Run
    │ │ │ │ -
    source

    pub fn pad(&mut self, s: &str) -> Result<(), Error>

    This function takes a string slice and emits it to the internal buffer │ │ │ │ +

    source

    pub fn pad(&mut self, s: &str) -> Result<(), Error>

    This function takes a string slice and emits it to the internal buffer │ │ │ │ after applying the relevant formatting flags specified. The flags │ │ │ │ recognized for generic strings are:

    │ │ │ │
      │ │ │ │
    • width - the minimum width of what to emit
      • │ │ │ │
    • fill/align - what to emit and where to emit it if the string │ │ │ │ provided needs to be padded
      • │ │ │ │
    • precision - the maximum length to emit, the string is truncated if it │ │ │ │ @@ -70,15 +70,15 @@ │ │ │ │ fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { │ │ │ │ formatter.pad("Foo") │ │ │ │ } │ │ │ │ } │ │ │ │ │ │ │ │ assert_eq!(format!("{Foo:<4}"), "Foo "); │ │ │ │ assert_eq!(format!("{Foo:0>4}"), "0Foo");Run
    │ │ │ │ -
    source

    pub fn write_str(&mut self, data: &str) -> Result<(), Error>

    Writes some data to the underlying buffer contained within this │ │ │ │ +

    source

    pub fn write_str(&mut self, data: &str) -> Result<(), Error>

    Writes some data to the underlying buffer contained within this │ │ │ │ formatter.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo;
│ │ │ │  
│ │ │ │  impl fmt::Display for Foo {
│ │ │ │ @@ -87,30 +87,30 @@
│ │ │ │          // This is equivalent to:
│ │ │ │          // write!(formatter, "Foo")
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(format!("{Foo}"), "Foo");
│ │ │ │  assert_eq!(format!("{Foo:0>8}"), "Foo");
    Run
    │ │ │ │ -
    source

    pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

    Writes some formatted information into this instance.

    │ │ │ │ +
    source

    pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

    Writes some formatted information into this instance.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(i32);
│ │ │ │  
│ │ │ │  impl fmt::Display for Foo {
│ │ │ │      fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │          formatter.write_fmt(format_args!("Foo {}", self.0))
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(format!("{}", Foo(-1)), "Foo -1");
│ │ │ │  assert_eq!(format!("{:0>8}", Foo(2)), "Foo 2");
    Run
    │ │ │ │ -
    source

    pub fn flags(&self) -> u32

    👎Deprecated since 1.24.0: use the sign_plus, sign_minus, alternate, or sign_aware_zero_pad methods instead

    Flags for formatting

    │ │ │ │ -
    1.5.0 · source

    pub fn fill(&self) -> char

    Character used as ‘fill’ whenever there is alignment.

    │ │ │ │ +
    source

    pub fn flags(&self) -> u32

    👎Deprecated since 1.24.0: use the sign_plus, sign_minus, alternate, or sign_aware_zero_pad methods instead

    Flags for formatting

    │ │ │ │ +
    1.5.0 · source

    pub fn fill(&self) -> char

    Character used as ‘fill’ whenever there is alignment.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo;
│ │ │ │  
│ │ │ │  impl fmt::Display for Foo {
│ │ │ │      fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -125,15 +125,15 @@
│ │ │ │          }
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  // We set alignment to the right with ">".
│ │ │ │  assert_eq!(format!("{Foo:G>3}"), "GGG");
│ │ │ │  assert_eq!(format!("{Foo:t>6}"), "tttttt");
    Run
    │ │ │ │ -
    1.28.0 · source

    pub fn align(&self) -> Option<Alignment>

    Flag indicating what form of alignment was requested.

    │ │ │ │ +
    1.28.0 · source

    pub fn align(&self) -> Option<Alignment>

    Flag indicating what form of alignment was requested.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt::{self, Alignment};
│ │ │ │  
│ │ │ │  struct Foo;
│ │ │ │  
│ │ │ │  impl fmt::Display for Foo {
│ │ │ │      fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -150,15 +150,15 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(format!("{Foo:<}"), "left");
│ │ │ │  assert_eq!(format!("{Foo:>}"), "right");
│ │ │ │  assert_eq!(format!("{Foo:^}"), "center");
│ │ │ │  assert_eq!(format!("{Foo}"), "into the void");
    Run
    │ │ │ │ -
    1.5.0 · source

    pub fn width(&self) -> Option<usize>

    Optionally specified integer width that the output should be.

    │ │ │ │ +
    1.5.0 · source

    pub fn width(&self) -> Option<usize>

    Optionally specified integer width that the output should be.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(i32);
│ │ │ │  
│ │ │ │  impl fmt::Display for Foo {
│ │ │ │      fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -170,15 +170,15 @@
│ │ │ │              write!(formatter, "Foo({})", self.0)
│ │ │ │          }
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(format!("{:10}", Foo(23)), "Foo(23)   ");
│ │ │ │  assert_eq!(format!("{}", Foo(23)), "Foo(23)");
    Run
    │ │ │ │ -
    1.5.0 · source

    pub fn precision(&self) -> Option<usize>

    Optionally specified precision for numeric types. Alternatively, the │ │ │ │ +

    1.5.0 · source

    pub fn precision(&self) -> Option<usize>

    Optionally specified precision for numeric types. Alternatively, the │ │ │ │ maximum width for string types.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(f32);
│ │ │ │  
│ │ │ │  impl fmt::Display for Foo {
│ │ │ │ @@ -191,15 +191,15 @@
│ │ │ │              write!(formatter, "Foo({:.2})", self.0)
│ │ │ │          }
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(format!("{:.4}", Foo(23.2)), "Foo(23.2000)");
│ │ │ │  assert_eq!(format!("{}", Foo(23.2)), "Foo(23.20)");
    Run
    │ │ │ │ -
    1.5.0 · source

    pub fn sign_plus(&self) -> bool

    Determines if the + flag was specified.

    │ │ │ │ +
    1.5.0 · source

    pub fn sign_plus(&self) -> bool

    Determines if the + flag was specified.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(i32);
│ │ │ │  
│ │ │ │  impl fmt::Display for Foo {
│ │ │ │      fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -213,15 +213,15 @@
│ │ │ │          }
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(format!("{:+}", Foo(23)), "Foo(+23)");
│ │ │ │  assert_eq!(format!("{:+}", Foo(-23)), "Foo(-23)");
│ │ │ │  assert_eq!(format!("{}", Foo(23)), "Foo(23)");
    Run
    │ │ │ │ -
    1.5.0 · source

    pub fn sign_minus(&self) -> bool

    Determines if the - flag was specified.

    │ │ │ │ +
    1.5.0 · source

    pub fn sign_minus(&self) -> bool

    Determines if the - flag was specified.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(i32);
│ │ │ │  
│ │ │ │  impl fmt::Display for Foo {
│ │ │ │      fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -232,15 +232,15 @@
│ │ │ │              write!(formatter, "Foo({})", self.0)
│ │ │ │          }
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(format!("{:-}", Foo(23)), "-Foo(23)");
│ │ │ │  assert_eq!(format!("{}", Foo(23)), "Foo(23)");
    Run
    │ │ │ │ -
    1.5.0 · source

    pub fn alternate(&self) -> bool

    Determines if the # flag was specified.

    │ │ │ │ +
    1.5.0 · source

    pub fn alternate(&self) -> bool

    Determines if the # flag was specified.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(i32);
│ │ │ │  
│ │ │ │  impl fmt::Display for Foo {
│ │ │ │      fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -250,15 +250,15 @@
│ │ │ │              write!(formatter, "{}", self.0)
│ │ │ │          }
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(format!("{:#}", Foo(23)), "Foo(23)");
│ │ │ │  assert_eq!(format!("{}", Foo(23)), "23");
    Run
    │ │ │ │ -
    1.5.0 · source

    pub fn sign_aware_zero_pad(&self) -> bool

    Determines if the 0 flag was specified.

    │ │ │ │ +
    1.5.0 · source

    pub fn sign_aware_zero_pad(&self) -> bool

    Determines if the 0 flag was specified.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(i32);
│ │ │ │  
│ │ │ │  impl fmt::Display for Foo {
│ │ │ │      fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │ @@ -266,15 +266,15 @@
│ │ │ │          assert_eq!(formatter.width(), Some(4));
│ │ │ │          // We ignore the formatter's options.
│ │ │ │          write!(formatter, "{}", self.0)
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(format!("{:04}", Foo(23)), "23");
    Run
    │ │ │ │ -
    1.2.0 · source

    pub fn debug_struct<'b>(&'b mut self, name: &str) -> DebugStruct<'b, 'a>

    Creates a DebugStruct builder designed to assist with creation of │ │ │ │ +

    1.2.0 · source

    pub fn debug_struct<'b>(&'b mut self, name: &str) -> DebugStruct<'b, 'a>

    Creates a DebugStruct builder designed to assist with creation of │ │ │ │ fmt::Debug implementations for structs.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  use std::net::Ipv4Addr;
│ │ │ │  
│ │ │ │  struct Foo {
│ │ │ │      bar: i32,
│ │ │ │ @@ -296,15 +296,15 @@
│ │ │ │      "Foo { bar: 10, baz: \"Hello World\", addr: 127.0.0.1 }",
│ │ │ │      format!("{:?}", Foo {
│ │ │ │          bar: 10,
│ │ │ │          baz: "Hello World".to_string(),
│ │ │ │          addr: Ipv4Addr::new(127, 0, 0, 1),
│ │ │ │      })
│ │ │ │  );
    Run
    │ │ │ │ -
    1.2.0 · source

    pub fn debug_tuple<'b>(&'b mut self, name: &str) -> DebugTuple<'b, 'a>

    Creates a DebugTuple builder designed to assist with creation of │ │ │ │ +

    1.2.0 · source

    pub fn debug_tuple<'b>(&'b mut self, name: &str) -> DebugTuple<'b, 'a>

    Creates a DebugTuple builder designed to assist with creation of │ │ │ │ fmt::Debug implementations for tuple structs.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  use std::marker::PhantomData;
│ │ │ │  
│ │ │ │  struct Foo<T>(i32, String, PhantomData<T>);
│ │ │ │  
│ │ │ │ @@ -318,43 +318,43 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      "Foo(10, \"Hello\", _)",
│ │ │ │      format!("{:?}", Foo(10, "Hello".to_string(), PhantomData::<u8>))
│ │ │ │  );
    Run
    │ │ │ │ -
    1.2.0 · source

    pub fn debug_list<'b>(&'b mut self) -> DebugList<'b, 'a>

    Creates a DebugList builder designed to assist with creation of │ │ │ │ +

    1.2.0 · source

    pub fn debug_list<'b>(&'b mut self) -> DebugList<'b, 'a>

    Creates a DebugList builder designed to assist with creation of │ │ │ │ fmt::Debug implementations for list-like structures.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(Vec<i32>);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │          fmt.debug_list().entries(self.0.iter()).finish()
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(format!("{:?}", Foo(vec![10, 11])), "[10, 11]");
    Run
    │ │ │ │ -
    1.2.0 · source

    pub fn debug_set<'b>(&'b mut self) -> DebugSet<'b, 'a>

    Creates a DebugSet builder designed to assist with creation of │ │ │ │ +

    1.2.0 · source

    pub fn debug_set<'b>(&'b mut self) -> DebugSet<'b, 'a>

    Creates a DebugSet builder designed to assist with creation of │ │ │ │ fmt::Debug implementations for set-like structures.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(Vec<i32>);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │          fmt.debug_set().entries(self.0.iter()).finish()
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(format!("{:?}", Foo(vec![10, 11])), "{10, 11}");
    Run
    │ │ │ │ -

    In this more complex example, we use format_args! and .debug_set() │ │ │ │ +

    In this more complex example, we use format_args! and .debug_set() │ │ │ │ to build a list of match arms:

    │ │ │ │ │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Arm<'a, L, R>(&'a (L, R));
│ │ │ │  struct Table<'a, K, V>(&'a [(K, V)], V);
│ │ │ │  
│ │ │ │ @@ -376,15 +376,15 @@
│ │ │ │      fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │          fmt.debug_set()
│ │ │ │          .entries(self.0.iter().map(Arm))
│ │ │ │          .entry(&Arm(&(format_args!("_"), &self.1)))
│ │ │ │          .finish()
│ │ │ │      }
│ │ │ │  }
    Run
    │ │ │ │ -
    1.2.0 · source

    pub fn debug_map<'b>(&'b mut self) -> DebugMap<'b, 'a>

    Creates a DebugMap builder designed to assist with creation of │ │ │ │ +

    1.2.0 · source

    pub fn debug_map<'b>(&'b mut self) -> DebugMap<'b, 'a>

    Creates a DebugMap builder designed to assist with creation of │ │ │ │ fmt::Debug implementations for map-like structures.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Foo(Vec<(String, i32)>);
│ │ │ │  
│ │ │ │  impl fmt::Debug for Foo {
│ │ │ │ @@ -393,19 +393,19 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("{:?}",  Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
│ │ │ │      r#"{"A": 10, "B": 11}"#
│ │ │ │   );
    Run
    │ │ │ │ -

    Trait Implementations§

    1.2.0 · source§

    impl Write for Formatter<'_>

    source§

    fn write_str(&mut self, s: &str) -> Result<(), Error>

    Writes a string slice into this writer, returning whether the write │ │ │ │ -succeeded. Read more
    source§

    fn write_char(&mut self, c: char) -> Result<(), Error>

    Writes a char into this writer, returning whether the write succeeded. Read more
    source§

    fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

    Glue for usage of the write! macro with implementors of this trait. Read more

    Auto Trait Implementations§

    §

    impl<'a> Freeze for Formatter<'a>

    §

    impl<'a> !RefUnwindSafe for Formatter<'a>

    §

    impl<'a> !Send for Formatter<'a>

    §

    impl<'a> !Sync for Formatter<'a>

    §

    impl<'a> Unpin for Formatter<'a>

    §

    impl<'a> !UnwindSafe for Formatter<'a>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    1.2.0 · source§

    impl Write for Formatter<'_>

    source§

    fn write_str(&mut self, s: &str) -> Result<(), Error>

    Writes a string slice into this writer, returning whether the write │ │ │ │ +succeeded. Read more
    source§

    fn write_char(&mut self, c: char) -> Result<(), Error>

    Writes a char into this writer, returning whether the write succeeded. Read more
    source§

    fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

    Glue for usage of the write! macro with implementors of this trait. Read more

    Auto Trait Implementations§

    §

    impl<'a> Freeze for Formatter<'a>

    §

    impl<'a> !RefUnwindSafe for Formatter<'a>

    §

    impl<'a> !Send for Formatter<'a>

    §

    impl<'a> !Sync for Formatter<'a>

    §

    impl<'a> Unpin for Formatter<'a>

    §

    impl<'a> !UnwindSafe for Formatter<'a>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/struct.FormatterFn.html │ │ │ │ @@ -1,35 +1,35 @@ │ │ │ │ FormatterFn in alloc::fmt - Rust
    │ │ │ │ -

    Struct alloc::fmt::FormatterFn

    source · 
    pub struct FormatterFn<F>(pub F)
│ │ │ │ +    
    Struct alloc::fmt::FormatterFn
    source · 
    pub struct FormatterFn<F>(pub F)
│ │ │ │  where
│ │ │ │ -    F: Fn(&mut Formatter<'_>) -> Result<(), Error>;
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)
    Expand description
    Implements fmt::Debug and fmt::Display using a function.
    
│ │ │ │ +    F: Fn(&mut Formatter<'_>) -> Result<(), Error>;
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)
    Expand description

    Implements fmt::Debug and fmt::Display using a function.

    │ │ │ │

    §Examples

    │ │ │ │ 
    #![feature(debug_closure_helpers)]
│ │ │ │  use std::fmt;
│ │ │ │  
│ │ │ │  let value = 'a';
│ │ │ │  assert_eq!(format!("{}", value), "a");
│ │ │ │  assert_eq!(format!("{:?}", value), "'a'");
│ │ │ │  
│ │ │ │  let wrapped = fmt::FormatterFn(|f| write!(f, "{:?}", &value));
│ │ │ │  assert_eq!(format!("{}", wrapped), "'a'");
│ │ │ │  assert_eq!(format!("{:?}", wrapped), "'a'");
    Run
    │ │ │ │ -

    Tuple Fields§

    §0: F
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)

    Trait Implementations§

    source§

    impl<F> Debug for FormatterFn<F>
    where │ │ │ │ - F: Fn(&mut Formatter<'_>) -> Result<(), Error>,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<F> Display for FormatterFn<F>
    where │ │ │ │ - F: Fn(&mut Formatter<'_>) -> Result<(), Error>,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<F> Freeze for FormatterFn<F>
    where │ │ │ │ - F: Freeze,

    §

    impl<F> RefUnwindSafe for FormatterFn<F>
    where │ │ │ │ - F: RefUnwindSafe,

    §

    impl<F> Send for FormatterFn<F>
    where │ │ │ │ - F: Send,

    §

    impl<F> Sync for FormatterFn<F>
    where │ │ │ │ - F: Sync,

    §

    impl<F> Unpin for FormatterFn<F>
    where │ │ │ │ - F: Unpin,

    §

    impl<F> UnwindSafe for FormatterFn<F>
    where │ │ │ │ - F: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Tuple Fields§

    §0: F
    🔬This is a nightly-only experimental API. (debug_closure_helpers #117729)

    Trait Implementations§

    source§

    impl<F> Debug for FormatterFn<F>
    where │ │ │ │ + F: Fn(&mut Formatter<'_>) -> Result<(), Error>,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<F> Display for FormatterFn<F>
    where │ │ │ │ + F: Fn(&mut Formatter<'_>) -> Result<(), Error>,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more

    Auto Trait Implementations§

    §

    impl<F> Freeze for FormatterFn<F>
    where │ │ │ │ + F: Freeze,

    §

    impl<F> RefUnwindSafe for FormatterFn<F>
    where │ │ │ │ + F: RefUnwindSafe,

    §

    impl<F> Send for FormatterFn<F>
    where │ │ │ │ + F: Send,

    §

    impl<F> Sync for FormatterFn<F>
    where │ │ │ │ + F: Sync,

    §

    impl<F> Unpin for FormatterFn<F>
    where │ │ │ │ + F: Unpin,

    §

    impl<F> UnwindSafe for FormatterFn<F>
    where │ │ │ │ + F: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Display + ?Sized,
    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Binary.html │ │ │ │ @@ -1,19 +1,19 @@ │ │ │ │ Binary in alloc::fmt - Rust
    │ │ │ │ -

    Trait alloc::fmt::Binary

    1.0.0 · source · 
    pub trait Binary {
│ │ │ │ +    
    Trait alloc::fmt::Binary
    1.0.0 · source · 
    pub trait Binary {
│ │ │ │      // Required method
│ │ │ │ -    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │ +    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │  }
    Expand description
    b formatting.
    
│ │ │ │  
    The Binary trait should format its output as a number in binary.
    
│ │ │ │ -
    For primitive signed integers (i8 to i128, and isize),
│ │ │ │ +
    For primitive signed integers (i8 to i128, and isize),
│ │ │ │  negative values are formatted as the two’s complement representation.
    
│ │ │ │  
    The alternate flag, #, adds a 0b in front of the output.
    
│ │ │ │  
    For more information on formatters, see the module-level documentation.
    
│ │ │ │  
    §Examples
    
│ │ │ │ -
    Basic usage with i32:
    
│ │ │ │ +
    Basic usage with i32:
    
│ │ │ │  
│ │ │ │  
    let x = 42; // 42 is '101010' in binary
│ │ │ │  
│ │ │ │  assert_eq!(format!("{x:b}"), "101010");
│ │ │ │  assert_eq!(format!("{x:#b}"), "0b101010");
│ │ │ │  
│ │ │ │  assert_eq!(format!("{:b}", -16), "11111111111111111111111111110000");
    Run
    
│ │ │ │ @@ -37,14 +37,14 @@
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      // Note that the `0b` prefix added by `#` is included in the total width, so we
│ │ │ │      // need to add two to correctly display all 32 bits.
│ │ │ │      format!("l as binary is: {l:#034b}"),
│ │ │ │      "l as binary is: 0b00000000000000000000000001101011"
│ │ │ │  );
    Run
    │ │ │ │ -

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ -

    Implementors§

    source§

    impl Binary for i8

    source§

    impl Binary for i16

    source§

    impl Binary for i32

    source§

    impl Binary for i64

    source§

    impl Binary for i128

    source§

    impl Binary for isize

    source§

    impl Binary for u8

    source§

    impl Binary for u16

    source§

    impl Binary for u32

    source§

    impl Binary for u64

    source§

    impl Binary for u128

    source§

    impl Binary for usize

    source§

    impl<T> Binary for &T
    where │ │ │ │ - T: Binary + ?Sized,

    source§

    impl<T> Binary for &mut T
    where │ │ │ │ - T: Binary + ?Sized,

    1.28.0 · source§

    impl<T> Binary for NonZero<T>
    where │ │ │ │ - T: ZeroablePrimitive + Binary,

    1.74.0 · source§

    impl<T> Binary for Saturating<T>
    where │ │ │ │ - T: Binary,

    1.11.0 · source§

    impl<T> Binary for Wrapping<T>
    where │ │ │ │ +

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ +

    Implementors§

    source§

    impl Binary for i8

    source§

    impl Binary for i16

    source§

    impl Binary for i32

    source§

    impl Binary for i64

    source§

    impl Binary for i128

    source§

    impl Binary for isize

    source§

    impl Binary for u8

    source§

    impl Binary for u16

    source§

    impl Binary for u32

    source§

    impl Binary for u64

    source§

    impl Binary for u128

    source§

    impl Binary for usize

    source§

    impl<T> Binary for &T
    where │ │ │ │ + T: Binary + ?Sized,

    source§

    impl<T> Binary for &mut T
    where │ │ │ │ + T: Binary + ?Sized,

    1.28.0 · source§

    impl<T> Binary for NonZero<T>
    where │ │ │ │ + T: ZeroablePrimitive + Binary,

    1.74.0 · source§

    impl<T> Binary for Saturating<T>
    where │ │ │ │ + T: Binary,

    1.11.0 · source§

    impl<T> Binary for Wrapping<T>
    where │ │ │ │ T: Binary,

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Debug.html │ │ │ │ @@ -1,11 +1,11 @@ │ │ │ │ Debug in alloc::fmt - Rust
    │ │ │ │ -

    Trait alloc::fmt::Debug

    1.0.0 · source · 
    pub trait Debug {
│ │ │ │ +    
    Trait alloc::fmt::Debug
    1.0.0 · source · 
    pub trait Debug {
│ │ │ │      // Required method
│ │ │ │ -    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │ +    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │  }
    Expand description
    ? formatting.
    
│ │ │ │  
    Debug should format the output in a programmer-facing, debugging context.
    
│ │ │ │  
    Generally speaking, you should just derive a Debug implementation.
    
│ │ │ │  
    When used with the alternate format specifier #?, the output is pretty-printed.
    
│ │ │ │  
    For more information on formatters, see the module-level documentation.
    
│ │ │ │  
    This trait can be used with #[derive] if all fields implement Debug. When
│ │ │ │  derived for structs, it will use the name of the struct, then {, then a
│ │ │ │ @@ -75,15 +75,15 @@
│ │ │ │  let origin = Point { x: 0, y: 0 };
│ │ │ │  
│ │ │ │  assert_eq!(format!("The origin is: {origin:#?}"),
│ │ │ │  "The origin is: Point {
│ │ │ │      x: 0,
│ │ │ │      y: 0,
│ │ │ │  }");
    Run
    │ │ │ │ -

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ +

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Position {
│ │ │ │      longitude: f32,
│ │ │ │      latitude: f32,
│ │ │ │  }
│ │ │ │ @@ -100,178 +100,178 @@
│ │ │ │  let position = Position { longitude: 1.987, latitude: 2.983 };
│ │ │ │  assert_eq!(format!("{position:?}"), "(1.987, 2.983)");
│ │ │ │  
│ │ │ │  assert_eq!(format!("{position:#?}"), "(
│ │ │ │      1.987,
│ │ │ │      2.983,
│ │ │ │  )");
    Run
    │ │ │ │ -

    Implementors§

    source§

    impl Debug for AsciiChar

    source§

    impl Debug for core::cmp::Ordering

    1.34.0 · source§

    impl Debug for Infallible

    1.16.0 · source§

    impl Debug for c_void

    1.7.0 · source§

    impl Debug for IpAddr

    source§

    impl Debug for Ipv6MulticastScope

    source§

    impl Debug for SocketAddr

    source§

    impl Debug for FpCategory

    1.55.0 · source§

    impl Debug for IntErrorKind

    source§

    impl Debug for core::sync::atomic::Ordering

    source§

    impl Debug for TryReserveErrorKind

    source§

    impl Debug for SearchStep

    1.28.0 · source§

    impl Debug for alloc::fmt::Alignment

    source§

    impl Debug for bool

    source§

    impl Debug for char

    source§

    impl Debug for f32

    source§

    impl Debug for f64

    source§

    impl Debug for i8

    source§

    impl Debug for i16

    source§

    impl Debug for i32

    source§

    impl Debug for i64

    source§

    impl Debug for i128

    source§

    impl Debug for isize

    source§

    impl Debug for !

    source§

    impl Debug for str

    source§

    impl Debug for u8

    source§

    impl Debug for u16

    source§

    impl Debug for u32

    source§

    impl Debug for u64

    source§

    impl Debug for u128

    source§

    impl Debug for ()

    source§

    impl Debug for usize

    source§

    impl Debug for TypeId

    1.34.0 · source§

    impl Debug for TryFromSliceError

    1.16.0 · source§

    impl Debug for core::ascii::EscapeDefault

    1.13.0 · source§

    impl Debug for BorrowError

    1.13.0 · source§

    impl Debug for BorrowMutError

    1.34.0 · source§

    impl Debug for CharTryFromError

    1.20.0 · source§

    impl Debug for ParseCharError

    1.9.0 · source§

    impl Debug for DecodeUtf16Error

    1.20.0 · source§

    impl Debug for core::char::EscapeDebug

    source§

    impl Debug for core::char::EscapeDefault

    source§

    impl Debug for core::char::EscapeUnicode

    source§

    impl Debug for ToLowercase

    source§

    impl Debug for ToUppercase

    1.59.0 · source§

    impl Debug for TryFromCharError

    1.27.0 · source§

    impl Debug for CpuidResult

    1.27.0 · source§

    impl Debug for __m128

    source§

    impl Debug for __m128bh

    1.27.0 · source§

    impl Debug for __m128d

    1.27.0 · source§

    impl Debug for __m128i

    1.27.0 · source§

    impl Debug for __m256

    source§

    impl Debug for __m256bh

    1.27.0 · source§

    impl Debug for __m256d

    1.27.0 · source§

    impl Debug for __m256i

    1.72.0 · source§

    impl Debug for __m512

    source§

    impl Debug for __m512bh

    1.72.0 · source§

    impl Debug for __m512d

    1.72.0 · source§

    impl Debug for __m512i

    1.3.0 · source§

    impl Debug for CStr

    1.69.0 · source§

    impl Debug for FromBytesUntilNulError

    1.64.0 · source§

    impl Debug for FromBytesWithNulError

    source§

    impl Debug for SipHasher

    source§

    impl Debug for BorrowedBuf<'_>

    1.33.0 · source§

    impl Debug for PhantomPinned

    source§

    impl Debug for Assume

    source§

    impl Debug for Ipv4Addr

    source§

    impl Debug for Ipv6Addr

    source§

    impl Debug for AddrParseError

    source§

    impl Debug for SocketAddrV4

    source§

    impl Debug for SocketAddrV6

    source§

    impl Debug for ParseFloatError

    source§

    impl Debug for ParseIntError

    1.34.0 · source§

    impl Debug for TryFromIntError

    source§

    impl Debug for RangeFull

    source§

    impl Debug for core::ptr::alignment::Alignment

    source§

    impl Debug for TimSortRun

    1.3.0 · source§

    impl Debug for AtomicBool

    1.34.0 · source§

    impl Debug for AtomicI8

    1.34.0 · source§

    impl Debug for AtomicI16

    1.34.0 · source§

    impl Debug for AtomicI32

    1.34.0 · source§

    impl Debug for AtomicI64

    1.3.0 · source§

    impl Debug for AtomicIsize

    1.34.0 · source§

    impl Debug for AtomicU8

    1.34.0 · source§

    impl Debug for AtomicU16

    1.34.0 · source§

    impl Debug for AtomicU32

    1.34.0 · source§

    impl Debug for AtomicU64

    1.3.0 · source§

    impl Debug for AtomicUsize

    1.36.0 · source§

    impl Debug for Context<'_>

    source§

    impl Debug for LocalWaker

    1.36.0 · source§

    impl Debug for RawWaker

    1.36.0 · source§

    impl Debug for RawWakerVTable

    1.36.0 · source§

    impl Debug for Waker

    1.27.0 · source§

    impl Debug for Duration

    1.66.0 · source§

    impl Debug for TryFromFloatSecsError

    source§

    impl Debug for AllocError

    source§

    impl Debug for Global

    1.28.0 · source§

    impl Debug for Layout

    1.50.0 · source§

    impl Debug for LayoutError

    source§

    impl Debug for UnorderedKeyError

    1.57.0 · source§

    impl Debug for TryReserveError

    1.64.0 · source§

    impl Debug for FromVecWithNulError

    1.64.0 · source§

    impl Debug for IntoStringError

    1.64.0 · source§

    impl Debug for NulError

    source§

    impl Debug for CString

    1.38.0 · source§

    impl Debug for Chars<'_>

    1.17.0 · source§

    impl Debug for EncodeUtf16<'_>

    source§

    impl Debug for ParseBoolError

    source§

    impl Debug for Utf8Chunks<'_>

    source§

    impl Debug for Utf8Error

    1.17.0 · source§

    impl Debug for alloc::string::Drain<'_>

    source§

    impl Debug for FromUtf8Error

    source§

    impl Debug for FromUtf16Error

    source§

    impl Debug for String

    source§

    impl Debug for Arguments<'_>

    source§

    impl Debug for Error

    source§

    impl Debug for dyn Any

    source§

    impl Debug for dyn Any + Send

    1.28.0 · source§

    impl Debug for dyn Any + Sync + Send

    source§

    impl<'a> Debug for Request<'a>

    source§

    impl<'a> Debug for Source<'a>

    source§

    impl<'a> Debug for core::ffi::c_str::Bytes<'a>

    source§

    impl<'a> Debug for BorrowedCursor<'a>

    1.10.0 · source§

    impl<'a> Debug for Location<'a>

    1.10.0 · source§

    impl<'a> Debug for PanicInfo<'a>

    source§

    impl<'a> Debug for ContextBuilder<'a>

    1.60.0 · source§

    impl<'a> Debug for EscapeAscii<'a>

    source§

    impl<'a> Debug for CharSearcher<'a>

    source§

    impl<'a> Debug for alloc::str::Bytes<'a>

    source§

    impl<'a> Debug for CharIndices<'a>

    1.34.0 · source§

    impl<'a> Debug for alloc::str::EscapeDebug<'a>

    1.34.0 · source§

    impl<'a> Debug for alloc::str::EscapeDefault<'a>

    1.34.0 · source§

    impl<'a> Debug for alloc::str::EscapeUnicode<'a>

    source§

    impl<'a> Debug for Lines<'a>

    source§

    impl<'a> Debug for LinesAny<'a>

    1.34.0 · source§

    impl<'a> Debug for SplitAsciiWhitespace<'a>

    1.1.0 · source§

    impl<'a> Debug for SplitWhitespace<'a>

    source§

    impl<'a> Debug for Utf8Chunk<'a>

    source§

    impl<'a, 'b> Debug for CharSliceSearcher<'a, 'b>

    source§

    impl<'a, 'b> Debug for StrSearcher<'a, 'b>

    source§

    impl<'a, 'b, const N: usize> Debug for CharArrayRefSearcher<'a, 'b, N>

    source§

    impl<'a, 'f> Debug for VaList<'a, 'f>
    where │ │ │ │ - 'f: 'a,

    source§

    impl<'a, A> Debug for core::option::Iter<'a, A>
    where │ │ │ │ - A: Debug + 'a,

    source§

    impl<'a, A> Debug for core::option::IterMut<'a, A>
    where │ │ │ │ - A: Debug + 'a,

    source§

    impl<'a, I> Debug for ByRefSized<'a, I>
    where │ │ │ │ - I: Debug,

    1.21.0 · source§

    impl<'a, I: Debug + Iterator + 'a, A: Debug + Allocator + 'a> Debug for Splice<'a, I, A>
    where │ │ │ │ - I::Item: Debug,

    1.5.0 · source§

    impl<'a, P> Debug for MatchIndices<'a, P>
    where │ │ │ │ - P: Pattern<'a>, │ │ │ │ - <P as Pattern<'a>>::Searcher: Debug,

    1.2.0 · source§

    impl<'a, P> Debug for Matches<'a, P>
    where │ │ │ │ - P: Pattern<'a>, │ │ │ │ - <P as Pattern<'a>>::Searcher: Debug,

    1.5.0 · source§

    impl<'a, P> Debug for RMatchIndices<'a, P>
    where │ │ │ │ - P: Pattern<'a>, │ │ │ │ - <P as Pattern<'a>>::Searcher: Debug,

    1.2.0 · source§

    impl<'a, P> Debug for RMatches<'a, P>
    where │ │ │ │ - P: Pattern<'a>, │ │ │ │ - <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for alloc::str::RSplit<'a, P>
    where │ │ │ │ - P: Pattern<'a>, │ │ │ │ - <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for alloc::str::RSplitN<'a, P>
    where │ │ │ │ - P: Pattern<'a>, │ │ │ │ - <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for RSplitTerminator<'a, P>
    where │ │ │ │ - P: Pattern<'a>, │ │ │ │ - <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for alloc::str::Split<'a, P>
    where │ │ │ │ - P: Pattern<'a>, │ │ │ │ - <P as Pattern<'a>>::Searcher: Debug,

    1.51.0 · source§

    impl<'a, P> Debug for alloc::str::SplitInclusive<'a, P>
    where │ │ │ │ - P: Pattern<'a>, │ │ │ │ - <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for alloc::str::SplitN<'a, P>
    where │ │ │ │ - P: Pattern<'a>, │ │ │ │ - <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for SplitTerminator<'a, P>
    where │ │ │ │ - P: Pattern<'a>, │ │ │ │ - <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, T> Debug for core::result::Iter<'a, T>
    where │ │ │ │ - T: Debug + 'a,

    source§

    impl<'a, T> Debug for core::result::IterMut<'a, T>
    where │ │ │ │ - T: Debug + 'a,

    source§

    impl<'a, T> Debug for Chunks<'a, T>
    where │ │ │ │ - T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for ChunksExact<'a, T>
    where │ │ │ │ - T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for ChunksExactMut<'a, T>
    where │ │ │ │ - T: Debug + 'a,

    source§

    impl<'a, T> Debug for ChunksMut<'a, T>
    where │ │ │ │ - T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for RChunks<'a, T>
    where │ │ │ │ - T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for RChunksExact<'a, T>
    where │ │ │ │ - T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for RChunksExactMut<'a, T>
    where │ │ │ │ - T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for RChunksMut<'a, T>
    where │ │ │ │ - T: Debug + 'a,

    source§

    impl<'a, T> Debug for Windows<'a, T>
    where │ │ │ │ - T: Debug + 'a,

    1.77.0 · source§

    impl<'a, T, P> Debug for ChunkBy<'a, T, P>
    where │ │ │ │ - T: 'a + Debug,

    1.77.0 · source§

    impl<'a, T, P> Debug for ChunkByMut<'a, T, P>
    where │ │ │ │ - T: 'a + Debug,

    source§

    impl<'a, T, const N: usize> Debug for alloc::slice::ArrayChunks<'a, T, N>
    where │ │ │ │ - T: Debug + 'a,

    source§

    impl<'a, T, const N: usize> Debug for ArrayChunksMut<'a, T, N>
    where │ │ │ │ - T: Debug + 'a,

    source§

    impl<'a, T, const N: usize> Debug for ArrayWindows<'a, T, N>
    where │ │ │ │ - T: Debug + 'a,

    1.17.0 · source§

    impl<'a, T: Debug + 'a> Debug for alloc::collections::btree_set::Range<'a, T>

    1.6.0 · source§

    impl<'a, T: Debug + 'a, A: Debug + Allocator> Debug for alloc::collections::binary_heap::Drain<'a, T, A>

    source§

    impl<'a, T: Debug + Ord, A: Debug + Allocator> Debug for DrainSorted<'a, T, A>

    source§

    impl<'a, T: Debug, F, A: Debug + Allocator> Debug for alloc::vec::ExtractIf<'a, T, F, A>
    where │ │ │ │ - F: FnMut(&mut T) -> bool + Debug,

    source§

    impl<'a, const N: usize> Debug for CharArraySearcher<'a, N>

    source§

    impl<'f> Debug for VaListImpl<'f>

    source§

    impl<A> Debug for Repeat<A>
    where │ │ │ │ - A: Debug,

    source§

    impl<A> Debug for RepeatN<A>
    where │ │ │ │ - A: Debug,

    source§

    impl<A> Debug for core::option::IntoIter<A>
    where │ │ │ │ - A: Debug,

    source§

    impl<A, B> Debug for Chain<A, B>
    where │ │ │ │ +

    Implementors§

    source§

    impl Debug for TryReserveErrorKind

    source§

    impl Debug for SearchStep

    1.28.0 · source§

    impl Debug for alloc::fmt::Alignment

    source§

    impl Debug for AsciiChar

    source§

    impl Debug for core::cmp::Ordering

    1.34.0 · source§

    impl Debug for Infallible

    1.16.0 · source§

    impl Debug for c_void

    1.7.0 · source§

    impl Debug for IpAddr

    source§

    impl Debug for Ipv6MulticastScope

    source§

    impl Debug for SocketAddr

    source§

    impl Debug for FpCategory

    1.55.0 · source§

    impl Debug for IntErrorKind

    source§

    impl Debug for core::sync::atomic::Ordering

    source§

    impl Debug for bool

    source§

    impl Debug for char

    source§

    impl Debug for f32

    source§

    impl Debug for f64

    source§

    impl Debug for i8

    source§

    impl Debug for i16

    source§

    impl Debug for i32

    source§

    impl Debug for i64

    source§

    impl Debug for i128

    source§

    impl Debug for isize

    source§

    impl Debug for !

    source§

    impl Debug for str

    source§

    impl Debug for u8

    source§

    impl Debug for u16

    source§

    impl Debug for u32

    source§

    impl Debug for u64

    source§

    impl Debug for u128

    source§

    impl Debug for ()

    source§

    impl Debug for usize

    source§

    impl Debug for AllocError

    source§

    impl Debug for Global

    1.28.0 · source§

    impl Debug for Layout

    1.50.0 · source§

    impl Debug for LayoutError

    source§

    impl Debug for UnorderedKeyError

    1.57.0 · source§

    impl Debug for TryReserveError

    1.64.0 · source§

    impl Debug for FromVecWithNulError

    1.64.0 · source§

    impl Debug for IntoStringError

    1.64.0 · source§

    impl Debug for NulError

    source§

    impl Debug for CString

    1.38.0 · source§

    impl Debug for Chars<'_>

    1.17.0 · source§

    impl Debug for EncodeUtf16<'_>

    source§

    impl Debug for ParseBoolError

    source§

    impl Debug for Utf8Chunks<'_>

    source§

    impl Debug for Utf8Error

    1.17.0 · source§

    impl Debug for alloc::string::Drain<'_>

    source§

    impl Debug for FromUtf8Error

    source§

    impl Debug for FromUtf16Error

    source§

    impl Debug for String

    source§

    impl Debug for TypeId

    1.34.0 · source§

    impl Debug for TryFromSliceError

    1.16.0 · source§

    impl Debug for core::ascii::EscapeDefault

    1.13.0 · source§

    impl Debug for BorrowError

    1.13.0 · source§

    impl Debug for BorrowMutError

    1.34.0 · source§

    impl Debug for CharTryFromError

    1.20.0 · source§

    impl Debug for ParseCharError

    1.9.0 · source§

    impl Debug for DecodeUtf16Error

    1.20.0 · source§

    impl Debug for core::char::EscapeDebug

    source§

    impl Debug for core::char::EscapeDefault

    source§

    impl Debug for core::char::EscapeUnicode

    source§

    impl Debug for ToLowercase

    source§

    impl Debug for ToUppercase

    1.59.0 · source§

    impl Debug for TryFromCharError

    1.27.0 · source§

    impl Debug for CpuidResult

    1.27.0 · source§

    impl Debug for __m128

    source§

    impl Debug for __m128bh

    1.27.0 · source§

    impl Debug for __m128d

    1.27.0 · source§

    impl Debug for __m128i

    1.27.0 · source§

    impl Debug for __m256

    source§

    impl Debug for __m256bh

    1.27.0 · source§

    impl Debug for __m256d

    1.27.0 · source§

    impl Debug for __m256i

    1.72.0 · source§

    impl Debug for __m512

    source§

    impl Debug for __m512bh

    1.72.0 · source§

    impl Debug for __m512d

    1.72.0 · source§

    impl Debug for __m512i

    1.3.0 · source§

    impl Debug for CStr

    1.69.0 · source§

    impl Debug for FromBytesUntilNulError

    1.64.0 · source§

    impl Debug for FromBytesWithNulError

    source§

    impl Debug for SipHasher

    source§

    impl Debug for BorrowedBuf<'_>

    1.33.0 · source§

    impl Debug for PhantomPinned

    source§

    impl Debug for Assume

    source§

    impl Debug for Ipv4Addr

    source§

    impl Debug for Ipv6Addr

    source§

    impl Debug for AddrParseError

    source§

    impl Debug for SocketAddrV4

    source§

    impl Debug for SocketAddrV6

    source§

    impl Debug for ParseFloatError

    source§

    impl Debug for ParseIntError

    1.34.0 · source§

    impl Debug for TryFromIntError

    source§

    impl Debug for RangeFull

    source§

    impl Debug for core::ptr::alignment::Alignment

    source§

    impl Debug for TimSortRun

    1.3.0 · source§

    impl Debug for AtomicBool

    1.34.0 · source§

    impl Debug for AtomicI8

    1.34.0 · source§

    impl Debug for AtomicI16

    1.34.0 · source§

    impl Debug for AtomicI32

    1.34.0 · source§

    impl Debug for AtomicI64

    1.3.0 · source§

    impl Debug for AtomicIsize

    1.34.0 · source§

    impl Debug for AtomicU8

    1.34.0 · source§

    impl Debug for AtomicU16

    1.34.0 · source§

    impl Debug for AtomicU32

    1.34.0 · source§

    impl Debug for AtomicU64

    1.3.0 · source§

    impl Debug for AtomicUsize

    1.36.0 · source§

    impl Debug for Context<'_>

    source§

    impl Debug for LocalWaker

    1.36.0 · source§

    impl Debug for RawWaker

    1.36.0 · source§

    impl Debug for RawWakerVTable

    1.36.0 · source§

    impl Debug for Waker

    1.27.0 · source§

    impl Debug for Duration

    1.66.0 · source§

    impl Debug for TryFromFloatSecsError

    source§

    impl Debug for Arguments<'_>

    source§

    impl Debug for Error

    source§

    impl Debug for dyn Any

    source§

    impl Debug for dyn Any + Send

    1.28.0 · source§

    impl Debug for dyn Any + Sync + Send

    1.60.0 · source§

    impl<'a> Debug for EscapeAscii<'a>

    source§

    impl<'a> Debug for CharSearcher<'a>

    source§

    impl<'a> Debug for alloc::str::Bytes<'a>

    source§

    impl<'a> Debug for CharIndices<'a>

    1.34.0 · source§

    impl<'a> Debug for alloc::str::EscapeDebug<'a>

    1.34.0 · source§

    impl<'a> Debug for alloc::str::EscapeDefault<'a>

    1.34.0 · source§

    impl<'a> Debug for alloc::str::EscapeUnicode<'a>

    source§

    impl<'a> Debug for Lines<'a>

    source§

    impl<'a> Debug for LinesAny<'a>

    1.34.0 · source§

    impl<'a> Debug for SplitAsciiWhitespace<'a>

    1.1.0 · source§

    impl<'a> Debug for SplitWhitespace<'a>

    source§

    impl<'a> Debug for Utf8Chunk<'a>

    source§

    impl<'a> Debug for Request<'a>

    source§

    impl<'a> Debug for Source<'a>

    source§

    impl<'a> Debug for core::ffi::c_str::Bytes<'a>

    source§

    impl<'a> Debug for BorrowedCursor<'a>

    1.10.0 · source§

    impl<'a> Debug for Location<'a>

    1.10.0 · source§

    impl<'a> Debug for PanicInfo<'a>

    source§

    impl<'a> Debug for ContextBuilder<'a>

    source§

    impl<'a, 'b> Debug for CharSliceSearcher<'a, 'b>

    source§

    impl<'a, 'b> Debug for StrSearcher<'a, 'b>

    source§

    impl<'a, 'b, const N: usize> Debug for CharArrayRefSearcher<'a, 'b, N>

    source§

    impl<'a, 'f> Debug for VaList<'a, 'f>
    where │ │ │ │ + 'f: 'a,

    source§

    impl<'a, A> Debug for core::option::Iter<'a, A>
    where │ │ │ │ + A: Debug + 'a,

    source§

    impl<'a, A> Debug for core::option::IterMut<'a, A>
    where │ │ │ │ + A: Debug + 'a,

    source§

    impl<'a, I> Debug for ByRefSized<'a, I>
    where │ │ │ │ + I: Debug,

    1.21.0 · source§

    impl<'a, I: Debug + Iterator + 'a, A: Debug + Allocator + 'a> Debug for Splice<'a, I, A>
    where │ │ │ │ + I::Item: Debug,

    1.5.0 · source§

    impl<'a, P> Debug for MatchIndices<'a, P>
    where │ │ │ │ + P: Pattern<'a>, │ │ │ │ + <P as Pattern<'a>>::Searcher: Debug,

    1.2.0 · source§

    impl<'a, P> Debug for Matches<'a, P>
    where │ │ │ │ + P: Pattern<'a>, │ │ │ │ + <P as Pattern<'a>>::Searcher: Debug,

    1.5.0 · source§

    impl<'a, P> Debug for RMatchIndices<'a, P>
    where │ │ │ │ + P: Pattern<'a>, │ │ │ │ + <P as Pattern<'a>>::Searcher: Debug,

    1.2.0 · source§

    impl<'a, P> Debug for RMatches<'a, P>
    where │ │ │ │ + P: Pattern<'a>, │ │ │ │ + <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for alloc::str::RSplit<'a, P>
    where │ │ │ │ + P: Pattern<'a>, │ │ │ │ + <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for alloc::str::RSplitN<'a, P>
    where │ │ │ │ + P: Pattern<'a>, │ │ │ │ + <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for RSplitTerminator<'a, P>
    where │ │ │ │ + P: Pattern<'a>, │ │ │ │ + <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for alloc::str::Split<'a, P>
    where │ │ │ │ + P: Pattern<'a>, │ │ │ │ + <P as Pattern<'a>>::Searcher: Debug,

    1.51.0 · source§

    impl<'a, P> Debug for alloc::str::SplitInclusive<'a, P>
    where │ │ │ │ + P: Pattern<'a>, │ │ │ │ + <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for alloc::str::SplitN<'a, P>
    where │ │ │ │ + P: Pattern<'a>, │ │ │ │ + <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, P> Debug for SplitTerminator<'a, P>
    where │ │ │ │ + P: Pattern<'a>, │ │ │ │ + <P as Pattern<'a>>::Searcher: Debug,

    source§

    impl<'a, T> Debug for Chunks<'a, T>
    where │ │ │ │ + T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for ChunksExact<'a, T>
    where │ │ │ │ + T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for ChunksExactMut<'a, T>
    where │ │ │ │ + T: Debug + 'a,

    source§

    impl<'a, T> Debug for ChunksMut<'a, T>
    where │ │ │ │ + T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for RChunks<'a, T>
    where │ │ │ │ + T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for RChunksExact<'a, T>
    where │ │ │ │ + T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for RChunksExactMut<'a, T>
    where │ │ │ │ + T: Debug + 'a,

    1.31.0 · source§

    impl<'a, T> Debug for RChunksMut<'a, T>
    where │ │ │ │ + T: Debug + 'a,

    source§

    impl<'a, T> Debug for Windows<'a, T>
    where │ │ │ │ + T: Debug + 'a,

    source§

    impl<'a, T> Debug for core::result::Iter<'a, T>
    where │ │ │ │ + T: Debug + 'a,

    source§

    impl<'a, T> Debug for core::result::IterMut<'a, T>
    where │ │ │ │ + T: Debug + 'a,

    1.77.0 · source§

    impl<'a, T, P> Debug for ChunkBy<'a, T, P>
    where │ │ │ │ + T: 'a + Debug,

    1.77.0 · source§

    impl<'a, T, P> Debug for ChunkByMut<'a, T, P>
    where │ │ │ │ + T: 'a + Debug,

    source§

    impl<'a, T, const N: usize> Debug for alloc::slice::ArrayChunks<'a, T, N>
    where │ │ │ │ + T: Debug + 'a,

    source§

    impl<'a, T, const N: usize> Debug for ArrayChunksMut<'a, T, N>
    where │ │ │ │ + T: Debug + 'a,

    source§

    impl<'a, T, const N: usize> Debug for ArrayWindows<'a, T, N>
    where │ │ │ │ + T: Debug + 'a,

    1.17.0 · source§

    impl<'a, T: Debug + 'a> Debug for alloc::collections::btree_set::Range<'a, T>

    1.6.0 · source§

    impl<'a, T: Debug + 'a, A: Debug + Allocator> Debug for alloc::collections::binary_heap::Drain<'a, T, A>

    source§

    impl<'a, T: Debug + Ord, A: Debug + Allocator> Debug for DrainSorted<'a, T, A>

    source§

    impl<'a, T: Debug, F, A: Debug + Allocator> Debug for alloc::vec::ExtractIf<'a, T, F, A>
    where │ │ │ │ + F: FnMut(&mut T) -> bool + Debug,

    source§

    impl<'a, const N: usize> Debug for CharArraySearcher<'a, N>

    source§

    impl<'f> Debug for VaListImpl<'f>

    source§

    impl<A> Debug for Repeat<A>
    where │ │ │ │ + A: Debug,

    source§

    impl<A> Debug for RepeatN<A>
    where │ │ │ │ + A: Debug,

    source§

    impl<A> Debug for core::option::IntoIter<A>
    where │ │ │ │ + A: Debug,

    source§

    impl<A, B> Debug for Chain<A, B>
    where │ │ │ │ A: Debug, │ │ │ │ - B: Debug,

    source§

    impl<A, B> Debug for Zip<A, B>
    where │ │ │ │ + B: Debug,

    source§

    impl<A, B> Debug for Zip<A, B>
    where │ │ │ │ A: Debug, │ │ │ │ B: Debug,

    source§

    impl<B> Debug for Cow<'_, B>
    where │ │ │ │ - B: Debug + ToOwned<Owned: Debug> + ?Sized,

    1.55.0 · source§

    impl<B, C> Debug for ControlFlow<B, C>
    where │ │ │ │ + B: Debug + ToOwned<Owned: Debug> + ?Sized,

    1.55.0 · source§

    impl<B, C> Debug for ControlFlow<B, C>
    where │ │ │ │ B: Debug, │ │ │ │ - C: Debug,

    source§

    impl<Dyn> Debug for DynMetadata<Dyn>
    where │ │ │ │ - Dyn: ?Sized,

    1.64.0 · source§

    impl<F> Debug for PollFn<F>

    1.34.0 · source§

    impl<F> Debug for FromFn<F>

    1.68.0 · source§

    impl<F> Debug for OnceWith<F>

    1.68.0 · source§

    impl<F> Debug for RepeatWith<F>

    source§

    impl<F> Debug for CharPredicateSearcher<'_, F>
    where │ │ │ │ - F: FnMut(char) -> bool,

    source§

    impl<F> Debug for FormatterFn<F>
    where │ │ │ │ - F: Fn(&mut Formatter<'_>) -> Result<(), Error>,

    1.4.0 · source§

    impl<F> Debug for F
    where │ │ │ │ - F: FnPtr,

    1.9.0 · source§

    impl<H> Debug for BuildHasherDefault<H>

    source§

    impl<I> Debug for FromIter<I>
    where │ │ │ │ - I: Debug,

    1.9.0 · source§

    impl<I> Debug for DecodeUtf16<I>
    where │ │ │ │ - I: Debug + Iterator<Item = u16>,

    1.1.0 · source§

    impl<I> Debug for Cloned<I>
    where │ │ │ │ - I: Debug,

    1.36.0 · source§

    impl<I> Debug for Copied<I>
    where │ │ │ │ - I: Debug,

    source§

    impl<I> Debug for Cycle<I>
    where │ │ │ │ - I: Debug,

    source§

    impl<I> Debug for Enumerate<I>
    where │ │ │ │ - I: Debug,

    source§

    impl<I> Debug for Fuse<I>
    where │ │ │ │ - I: Debug,

    source§

    impl<I> Debug for Intersperse<I>
    where │ │ │ │ - I: Debug + Iterator, │ │ │ │ - <I as Iterator>::Item: Clone + Debug,

    source§

    impl<I> Debug for Peekable<I>
    where │ │ │ │ - I: Debug + Iterator, │ │ │ │ - <I as Iterator>::Item: Debug,

    source§

    impl<I> Debug for Skip<I>
    where │ │ │ │ - I: Debug,

    1.28.0 · source§

    impl<I> Debug for StepBy<I>
    where │ │ │ │ - I: Debug,

    source§

    impl<I> Debug for Take<I>
    where │ │ │ │ - I: Debug,

    1.9.0 · source§

    impl<I, F> Debug for FilterMap<I, F>
    where │ │ │ │ - I: Debug,

    1.9.0 · source§

    impl<I, F> Debug for Inspect<I, F>
    where │ │ │ │ - I: Debug,

    1.9.0 · source§

    impl<I, F> Debug for Map<I, F>
    where │ │ │ │ - I: Debug,

    source§

    impl<I, F, const N: usize> Debug for MapWindows<I, F, N>
    where │ │ │ │ - I: Iterator + Debug,

    source§

    impl<I, G> Debug for IntersperseWith<I, G>
    where │ │ │ │ - I: Iterator + Debug, │ │ │ │ - <I as Iterator>::Item: Debug, │ │ │ │ - G: Debug,

    1.9.0 · source§

    impl<I, P> Debug for Filter<I, P>
    where │ │ │ │ - I: Debug,

    1.57.0 · source§

    impl<I, P> Debug for MapWhile<I, P>
    where │ │ │ │ - I: Debug,

    1.9.0 · source§

    impl<I, P> Debug for SkipWhile<I, P>
    where │ │ │ │ - I: Debug,

    1.9.0 · source§

    impl<I, P> Debug for TakeWhile<I, P>
    where │ │ │ │ - I: Debug,

    1.9.0 · source§

    impl<I, St, F> Debug for Scan<I, St, F>
    where │ │ │ │ + C: Debug,

    source§

    impl<Dyn> Debug for DynMetadata<Dyn>
    where │ │ │ │ + Dyn: ?Sized,

    source§

    impl<F> Debug for CharPredicateSearcher<'_, F>
    where │ │ │ │ + F: FnMut(char) -> bool,

    1.64.0 · source§

    impl<F> Debug for PollFn<F>

    1.34.0 · source§

    impl<F> Debug for FromFn<F>

    1.68.0 · source§

    impl<F> Debug for OnceWith<F>

    1.68.0 · source§

    impl<F> Debug for RepeatWith<F>

    source§

    impl<F> Debug for FormatterFn<F>
    where │ │ │ │ + F: Fn(&mut Formatter<'_>) -> Result<(), Error>,

    1.4.0 · source§

    impl<F> Debug for F
    where │ │ │ │ + F: FnPtr,

    1.9.0 · source§

    impl<H> Debug for BuildHasherDefault<H>

    source§

    impl<I> Debug for FromIter<I>
    where │ │ │ │ + I: Debug,

    1.9.0 · source§

    impl<I> Debug for DecodeUtf16<I>
    where │ │ │ │ + I: Debug + Iterator<Item = u16>,

    1.1.0 · source§

    impl<I> Debug for Cloned<I>
    where │ │ │ │ + I: Debug,

    1.36.0 · source§

    impl<I> Debug for Copied<I>
    where │ │ │ │ + I: Debug,

    source§

    impl<I> Debug for Cycle<I>
    where │ │ │ │ + I: Debug,

    source§

    impl<I> Debug for Enumerate<I>
    where │ │ │ │ + I: Debug,

    source§

    impl<I> Debug for Fuse<I>
    where │ │ │ │ + I: Debug,

    source§

    impl<I> Debug for Intersperse<I>
    where │ │ │ │ + I: Debug + Iterator, │ │ │ │ + <I as Iterator>::Item: Clone + Debug,

    source§

    impl<I> Debug for Peekable<I>
    where │ │ │ │ + I: Debug + Iterator, │ │ │ │ + <I as Iterator>::Item: Debug,

    source§

    impl<I> Debug for Skip<I>
    where │ │ │ │ + I: Debug,

    1.28.0 · source§

    impl<I> Debug for StepBy<I>
    where │ │ │ │ + I: Debug,

    source§

    impl<I> Debug for Take<I>
    where │ │ │ │ + I: Debug,

    1.9.0 · source§

    impl<I, F> Debug for FilterMap<I, F>
    where │ │ │ │ + I: Debug,

    1.9.0 · source§

    impl<I, F> Debug for Inspect<I, F>
    where │ │ │ │ + I: Debug,

    1.9.0 · source§

    impl<I, F> Debug for Map<I, F>
    where │ │ │ │ + I: Debug,

    source§

    impl<I, F, const N: usize> Debug for MapWindows<I, F, N>
    where │ │ │ │ + I: Iterator + Debug,

    source§

    impl<I, G> Debug for IntersperseWith<I, G>
    where │ │ │ │ + I: Iterator + Debug, │ │ │ │ + <I as Iterator>::Item: Debug, │ │ │ │ + G: Debug,

    1.9.0 · source§

    impl<I, P> Debug for Filter<I, P>
    where │ │ │ │ + I: Debug,

    1.57.0 · source§

    impl<I, P> Debug for MapWhile<I, P>
    where │ │ │ │ + I: Debug,

    1.9.0 · source§

    impl<I, P> Debug for SkipWhile<I, P>
    where │ │ │ │ + I: Debug,

    1.9.0 · source§

    impl<I, P> Debug for TakeWhile<I, P>
    where │ │ │ │ + I: Debug,

    1.9.0 · source§

    impl<I, St, F> Debug for Scan<I, St, F>
    where │ │ │ │ I: Debug, │ │ │ │ - St: Debug,

    1.29.0 · source§

    impl<I, U> Debug for Flatten<I>
    where │ │ │ │ - I: Debug + Iterator, │ │ │ │ - <I as Iterator>::Item: IntoIterator<IntoIter = U, Item = <U as Iterator>::Item>, │ │ │ │ - U: Debug + Iterator,

    1.9.0 · source§

    impl<I, U, F> Debug for FlatMap<I, U, F>
    where │ │ │ │ + St: Debug,

    1.29.0 · source§

    impl<I, U> Debug for Flatten<I>
    where │ │ │ │ + I: Debug + Iterator, │ │ │ │ + <I as Iterator>::Item: IntoIterator<IntoIter = U, Item = <U as Iterator>::Item>, │ │ │ │ + U: Debug + Iterator,

    1.9.0 · source§

    impl<I, U, F> Debug for FlatMap<I, U, F>
    where │ │ │ │ I: Debug, │ │ │ │ - U: IntoIterator, │ │ │ │ - <U as IntoIterator>::IntoIter: Debug,

    source§

    impl<I, const N: usize> Debug for core::iter::adapters::array_chunks::ArrayChunks<I, N>
    where │ │ │ │ - I: Debug + Iterator, │ │ │ │ - <I as Iterator>::Item: Debug,

    source§

    impl<Idx> Debug for core::ops::range::Range<Idx>
    where │ │ │ │ - Idx: Debug,

    source§

    impl<Idx> Debug for RangeFrom<Idx>
    where │ │ │ │ - Idx: Debug,

    1.26.0 · source§

    impl<Idx> Debug for RangeInclusive<Idx>
    where │ │ │ │ - Idx: Debug,

    source§

    impl<Idx> Debug for RangeTo<Idx>
    where │ │ │ │ - Idx: Debug,

    1.26.0 · source§

    impl<Idx> Debug for RangeToInclusive<Idx>
    where │ │ │ │ + U: IntoIterator, │ │ │ │ + <U as IntoIterator>::IntoIter: Debug,

    source§

    impl<I, const N: usize> Debug for core::iter::adapters::array_chunks::ArrayChunks<I, N>
    where │ │ │ │ + I: Debug + Iterator, │ │ │ │ + <I as Iterator>::Item: Debug,

    source§

    impl<Idx> Debug for core::ops::range::Range<Idx>
    where │ │ │ │ + Idx: Debug,

    source§

    impl<Idx> Debug for RangeFrom<Idx>
    where │ │ │ │ + Idx: Debug,

    1.26.0 · source§

    impl<Idx> Debug for RangeInclusive<Idx>
    where │ │ │ │ + Idx: Debug,

    source§

    impl<Idx> Debug for RangeTo<Idx>
    where │ │ │ │ + Idx: Debug,

    1.26.0 · source§

    impl<Idx> Debug for RangeToInclusive<Idx>
    where │ │ │ │ Idx: Debug,

    source§

    impl<K, V, F> Debug for alloc::collections::btree_map::ExtractIf<'_, K, V, F>
    where │ │ │ │ K: Debug, │ │ │ │ V: Debug, │ │ │ │ - F: FnMut(&K, &mut V) -> bool,

    1.17.0 · source§

    impl<K, V: Debug> Debug for Values<'_, K, V>

    1.10.0 · source§

    impl<K, V: Debug> Debug for ValuesMut<'_, K, V>

    1.54.0 · source§

    impl<K, V: Debug, A: Allocator + Clone> Debug for IntoValues<K, V, A>

    1.12.0 · source§

    impl<K: Debug + Ord, V, A: Allocator + Clone> Debug for VacantEntry<'_, K, V, A>

    1.12.0 · source§

    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for Entry<'_, K, V, A>

    1.12.0 · source§

    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedEntry<'_, K, V, A>

    source§

    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedError<'_, K, V, A>

    1.17.0 · source§

    impl<K: Debug, V> Debug for Keys<'_, K, V>

    1.54.0 · source§

    impl<K: Debug, V, A: Allocator + Clone> Debug for IntoKeys<K, V, A>

    source§

    impl<K: Debug, V: Debug> Debug for alloc::collections::btree_map::Cursor<'_, K, V>

    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for alloc::collections::btree_map::Iter<'_, K, V>

    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for alloc::collections::btree_map::IterMut<'_, K, V>

    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for alloc::collections::btree_map::Range<'_, K, V>

    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for RangeMut<'_, K, V>

    source§

    impl<K: Debug, V: Debug, A> Debug for alloc::collections::btree_map::CursorMut<'_, K, V, A>

    source§

    impl<K: Debug, V: Debug, A> Debug for CursorMutKey<'_, K, V, A>

    source§

    impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for BTreeMap<K, V, A>

    1.17.0 · source§

    impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for alloc::collections::btree_map::IntoIter<K, V, A>

    1.33.0 · source§

    impl<Ptr> Debug for Pin<Ptr>
    where │ │ │ │ - Ptr: Debug,

    1.17.0 · source§

    impl<T> Debug for Bound<T>
    where │ │ │ │ - T: Debug,

    source§

    impl<T> Debug for Option<T>
    where │ │ │ │ - T: Debug,

    1.36.0 · source§

    impl<T> Debug for Poll<T>
    where │ │ │ │ - T: Debug,

    source§

    impl<T> Debug for *const T
    where │ │ │ │ - T: ?Sized,

    source§

    impl<T> Debug for *mut T
    where │ │ │ │ - T: ?Sized,

    source§

    impl<T> Debug for &T
    where │ │ │ │ - T: Debug + ?Sized,

    source§

    impl<T> Debug for &mut T
    where │ │ │ │ - T: Debug + ?Sized,

    source§

    impl<T> Debug for [T]
    where │ │ │ │ - T: Debug,

    source§

    impl<T> Debug for (T₁, T₂, …, Tₙ)
    where │ │ │ │ - T: Debug + ?Sized,

    This trait is implemented for tuples up to twelve items long.

    │ │ │ │ -
    1.70.0 · source§

    impl<T> Debug for OnceCell<T>
    where │ │ │ │ - T: Debug,

    source§

    impl<T> Debug for Cell<T>
    where │ │ │ │ - T: Copy + Debug,

    source§

    impl<T> Debug for Ref<'_, T>
    where │ │ │ │ - T: Debug + ?Sized,

    source§

    impl<T> Debug for RefCell<T>
    where │ │ │ │ - T: Debug + ?Sized,

    source§

    impl<T> Debug for RefMut<'_, T>
    where │ │ │ │ - T: Debug + ?Sized,

    source§

    impl<T> Debug for SyncUnsafeCell<T>
    where │ │ │ │ - T: ?Sized,

    1.9.0 · source§

    impl<T> Debug for UnsafeCell<T>
    where │ │ │ │ - T: ?Sized,

    1.19.0 · source§

    impl<T> Debug for Reverse<T>
    where │ │ │ │ - T: Debug,

    1.48.0 · source§

    impl<T> Debug for Pending<T>

    1.48.0 · source§

    impl<T> Debug for Ready<T>
    where │ │ │ │ - T: Debug,

    source§

    impl<T> Debug for Rev<T>
    where │ │ │ │ - T: Debug,

    1.9.0 · source§

    impl<T> Debug for Empty<T>

    1.2.0 · source§

    impl<T> Debug for Once<T>
    where │ │ │ │ - T: Debug,

    source§

    impl<T> Debug for PhantomData<T>
    where │ │ │ │ - T: ?Sized,

    1.20.0 · source§

    impl<T> Debug for ManuallyDrop<T>
    where │ │ │ │ - T: Debug + ?Sized,

    1.21.0 · source§

    impl<T> Debug for Discriminant<T>

    1.28.0 · source§

    impl<T> Debug for NonZero<T>
    where │ │ │ │ - T: ZeroablePrimitive + Debug,

    1.74.0 · source§

    impl<T> Debug for Saturating<T>
    where │ │ │ │ - T: Debug,

    source§

    impl<T> Debug for Wrapping<T>
    where │ │ │ │ - T: Debug,

    source§

    impl<T> Debug for Yeet<T>
    where │ │ │ │ - T: Debug,

    1.16.0 · source§

    impl<T> Debug for AssertUnwindSafe<T>
    where │ │ │ │ - T: Debug,

    1.25.0 · source§

    impl<T> Debug for NonNull<T>
    where │ │ │ │ - T: ?Sized,

    source§

    impl<T> Debug for core::result::IntoIter<T>
    where │ │ │ │ - T: Debug,

    1.3.0 · source§

    impl<T> Debug for AtomicPtr<T>

    source§

    impl<T> Debug for Exclusive<T>
    where │ │ │ │ - T: ?Sized,

    1.9.0 · source§

    impl<T> Debug for alloc::slice::Iter<'_, T>
    where │ │ │ │ - T: Debug,

    1.9.0 · source§

    impl<T> Debug for alloc::slice::IterMut<'_, T>
    where │ │ │ │ - T: Debug,

    1.41.0 · source§

    impl<T> Debug for MaybeUninit<T>

    source§

    impl<T, E> Debug for Result<T, E>
    where │ │ │ │ - T: Debug, │ │ │ │ - E: Debug,

    source§

    impl<T, F> Debug for LazyCell<T, F>
    where │ │ │ │ - T: Debug,

    1.34.0 · source§

    impl<T, F> Debug for Successors<T, F>
    where │ │ │ │ - T: Debug,

    source§

    impl<T, F, A: Allocator + Clone> Debug for alloc::collections::btree_set::ExtractIf<'_, T, F, A>
    where │ │ │ │ - T: Debug, │ │ │ │ - F: FnMut(&T) -> bool,

    1.27.0 · source§

    impl<T, P> Debug for alloc::slice::RSplit<'_, T, P>
    where │ │ │ │ - T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    1.27.0 · source§

    impl<T, P> Debug for RSplitMut<'_, T, P>
    where │ │ │ │ - T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for alloc::slice::RSplitN<'_, T, P>
    where │ │ │ │ - T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for RSplitNMut<'_, T, P>
    where │ │ │ │ - T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for alloc::slice::Split<'_, T, P>
    where │ │ │ │ - T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    1.51.0 · source§

    impl<T, P> Debug for alloc::slice::SplitInclusive<'_, T, P>
    where │ │ │ │ - T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    1.51.0 · source§

    impl<T, P> Debug for SplitInclusiveMut<'_, T, P>
    where │ │ │ │ - T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for SplitMut<'_, T, P>
    where │ │ │ │ - T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for alloc::slice::SplitN<'_, T, P>
    where │ │ │ │ - T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for SplitNMut<'_, T, P>
    where │ │ │ │ - T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    impl<T, const N: usize> Debug for [T; N]
    where │ │ │ │ - T: Debug,

    1.40.0 · source§

    impl<T, const N: usize> Debug for core::array::iter::IntoIter<T, N>
    where │ │ │ │ - T: Debug,

    source§

    impl<T, const N: usize> Debug for Mask<T, N>
    where │ │ │ │ - T: MaskElement + Debug, │ │ │ │ - LaneCount<N>: SupportedLaneCount,

    source§

    impl<T, const N: usize> Debug for Simd<T, N>
    where │ │ │ │ - LaneCount<N>: SupportedLaneCount, │ │ │ │ - T: SimdElement + Debug,

    1.17.0 · source§

    impl<T: Ord + Debug, A: Allocator> Debug for PeekMut<'_, T, A>

    source§

    impl<T: Debug + ?Sized, A: Allocator> Debug for Box<T, A>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::binary_heap::Iter<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::btree_set::Iter<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for SymmetricDifference<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for Union<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::linked_list::Iter<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::linked_list::IterMut<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::vec_deque::Iter<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::vec_deque::IterMut<'_, T>

    source§

    impl<T: Debug> Debug for UniqueRc<T>

    source§

    impl<T: Debug, A: Allocator + Clone> Debug for BTreeSet<T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator + Clone> Debug for Difference<'_, T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator + Clone> Debug for Intersection<'_, T, A>

    1.4.0 · source§

    impl<T: Debug, A: Allocator> Debug for BinaryHeap<T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::binary_heap::IntoIter<T, A>

    source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::linked_list::Cursor<'_, T, A>

    source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::linked_list::CursorMut<'_, T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::linked_list::IntoIter<T, A>

    source§

    impl<T: Debug, A: Allocator> Debug for LinkedList<T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::vec_deque::Drain<'_, T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::vec_deque::IntoIter<T, A>

    source§

    impl<T: Debug, A: Allocator> Debug for VecDeque<T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::vec::Drain<'_, T, A>

    1.13.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::vec::IntoIter<T, A>

    source§

    impl<T: Debug, A: Allocator> Debug for Vec<T, A>

    source§

    impl<T: Debug, A: Debug + Allocator + Clone> Debug for alloc::collections::btree_set::IntoIter<T, A>

    source§

    impl<T: Debug, A: Debug + Allocator> Debug for IntoIterSorted<T, A>

    source§

    impl<T: Debug, F> Debug for alloc::collections::linked_list::ExtractIf<'_, T, F>
    where │ │ │ │ - F: FnMut(&mut T) -> bool,

    source§

    impl<T: ?Sized + Debug> Debug for ThinBox<T>

    source§

    impl<T: ?Sized + Debug, A: Allocator> Debug for Rc<T, A>

    source§

    impl<T: ?Sized + Debug, A: Allocator> Debug for Arc<T, A>

    1.4.0 · source§

    impl<T: ?Sized> Debug for alloc::sync::Weak<T>

    1.4.0 · source§

    impl<T: ?Sized, A: Allocator> Debug for alloc::rc::Weak<T, A>

    source§

    impl<Y, R> Debug for CoroutineState<Y, R>
    where │ │ │ │ + F: FnMut(&K, &mut V) -> bool,

    1.17.0 · source§

    impl<K, V: Debug> Debug for Values<'_, K, V>

    1.10.0 · source§

    impl<K, V: Debug> Debug for ValuesMut<'_, K, V>

    1.54.0 · source§

    impl<K, V: Debug, A: Allocator + Clone> Debug for IntoValues<K, V, A>

    1.12.0 · source§

    impl<K: Debug + Ord, V, A: Allocator + Clone> Debug for VacantEntry<'_, K, V, A>

    1.12.0 · source§

    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for Entry<'_, K, V, A>

    1.12.0 · source§

    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedEntry<'_, K, V, A>

    source§

    impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedError<'_, K, V, A>

    1.17.0 · source§

    impl<K: Debug, V> Debug for Keys<'_, K, V>

    1.54.0 · source§

    impl<K: Debug, V, A: Allocator + Clone> Debug for IntoKeys<K, V, A>

    source§

    impl<K: Debug, V: Debug> Debug for alloc::collections::btree_map::Cursor<'_, K, V>

    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for alloc::collections::btree_map::Iter<'_, K, V>

    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for alloc::collections::btree_map::IterMut<'_, K, V>

    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for alloc::collections::btree_map::Range<'_, K, V>

    1.17.0 · source§

    impl<K: Debug, V: Debug> Debug for RangeMut<'_, K, V>

    source§

    impl<K: Debug, V: Debug, A> Debug for alloc::collections::btree_map::CursorMut<'_, K, V, A>

    source§

    impl<K: Debug, V: Debug, A> Debug for CursorMutKey<'_, K, V, A>

    source§

    impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for BTreeMap<K, V, A>

    1.17.0 · source§

    impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for alloc::collections::btree_map::IntoIter<K, V, A>

    1.33.0 · source§

    impl<Ptr> Debug for Pin<Ptr>
    where │ │ │ │ + Ptr: Debug,

    1.17.0 · source§

    impl<T> Debug for Bound<T>
    where │ │ │ │ + T: Debug,

    source§

    impl<T> Debug for Option<T>
    where │ │ │ │ + T: Debug,

    1.36.0 · source§

    impl<T> Debug for Poll<T>
    where │ │ │ │ + T: Debug,

    source§

    impl<T> Debug for *const T
    where │ │ │ │ + T: ?Sized,

    source§

    impl<T> Debug for *mut T
    where │ │ │ │ + T: ?Sized,

    source§

    impl<T> Debug for &T
    where │ │ │ │ + T: Debug + ?Sized,

    source§

    impl<T> Debug for &mut T
    where │ │ │ │ + T: Debug + ?Sized,

    source§

    impl<T> Debug for [T]
    where │ │ │ │ + T: Debug,

    source§

    impl<T> Debug for (T₁, T₂, …, Tₙ)
    where │ │ │ │ + T: Debug + ?Sized,

    This trait is implemented for tuples up to twelve items long.

    │ │ │ │ +
    1.9.0 · source§

    impl<T> Debug for alloc::slice::Iter<'_, T>
    where │ │ │ │ + T: Debug,

    1.9.0 · source§

    impl<T> Debug for alloc::slice::IterMut<'_, T>
    where │ │ │ │ + T: Debug,

    1.70.0 · source§

    impl<T> Debug for OnceCell<T>
    where │ │ │ │ + T: Debug,

    source§

    impl<T> Debug for Cell<T>
    where │ │ │ │ + T: Copy + Debug,

    source§

    impl<T> Debug for Ref<'_, T>
    where │ │ │ │ + T: Debug + ?Sized,

    source§

    impl<T> Debug for RefCell<T>
    where │ │ │ │ + T: Debug + ?Sized,

    source§

    impl<T> Debug for RefMut<'_, T>
    where │ │ │ │ + T: Debug + ?Sized,

    source§

    impl<T> Debug for SyncUnsafeCell<T>
    where │ │ │ │ + T: ?Sized,

    1.9.0 · source§

    impl<T> Debug for UnsafeCell<T>
    where │ │ │ │ + T: ?Sized,

    1.19.0 · source§

    impl<T> Debug for Reverse<T>
    where │ │ │ │ + T: Debug,

    1.48.0 · source§

    impl<T> Debug for Pending<T>

    1.48.0 · source§

    impl<T> Debug for Ready<T>
    where │ │ │ │ + T: Debug,

    source§

    impl<T> Debug for Rev<T>
    where │ │ │ │ + T: Debug,

    1.9.0 · source§

    impl<T> Debug for Empty<T>

    1.2.0 · source§

    impl<T> Debug for Once<T>
    where │ │ │ │ + T: Debug,

    source§

    impl<T> Debug for PhantomData<T>
    where │ │ │ │ + T: ?Sized,

    1.20.0 · source§

    impl<T> Debug for ManuallyDrop<T>
    where │ │ │ │ + T: Debug + ?Sized,

    1.21.0 · source§

    impl<T> Debug for Discriminant<T>

    1.28.0 · source§

    impl<T> Debug for NonZero<T>
    where │ │ │ │ + T: ZeroablePrimitive + Debug,

    1.74.0 · source§

    impl<T> Debug for Saturating<T>
    where │ │ │ │ + T: Debug,

    source§

    impl<T> Debug for Wrapping<T>
    where │ │ │ │ + T: Debug,

    source§

    impl<T> Debug for Yeet<T>
    where │ │ │ │ + T: Debug,

    1.16.0 · source§

    impl<T> Debug for AssertUnwindSafe<T>
    where │ │ │ │ + T: Debug,

    1.25.0 · source§

    impl<T> Debug for NonNull<T>
    where │ │ │ │ + T: ?Sized,

    source§

    impl<T> Debug for core::result::IntoIter<T>
    where │ │ │ │ + T: Debug,

    1.3.0 · source§

    impl<T> Debug for AtomicPtr<T>

    source§

    impl<T> Debug for Exclusive<T>
    where │ │ │ │ + T: ?Sized,

    1.41.0 · source§

    impl<T> Debug for MaybeUninit<T>

    source§

    impl<T, E> Debug for Result<T, E>
    where │ │ │ │ + T: Debug, │ │ │ │ + E: Debug,

    source§

    impl<T, F> Debug for LazyCell<T, F>
    where │ │ │ │ + T: Debug,

    1.34.0 · source§

    impl<T, F> Debug for Successors<T, F>
    where │ │ │ │ + T: Debug,

    source§

    impl<T, F, A: Allocator + Clone> Debug for alloc::collections::btree_set::ExtractIf<'_, T, F, A>
    where │ │ │ │ + T: Debug, │ │ │ │ + F: FnMut(&T) -> bool,

    1.27.0 · source§

    impl<T, P> Debug for alloc::slice::RSplit<'_, T, P>
    where │ │ │ │ + T: Debug, │ │ │ │ + P: FnMut(&T) -> bool,

    1.27.0 · source§

    impl<T, P> Debug for RSplitMut<'_, T, P>
    where │ │ │ │ + T: Debug, │ │ │ │ + P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for alloc::slice::RSplitN<'_, T, P>
    where │ │ │ │ + T: Debug, │ │ │ │ + P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for RSplitNMut<'_, T, P>
    where │ │ │ │ + T: Debug, │ │ │ │ + P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for alloc::slice::Split<'_, T, P>
    where │ │ │ │ + T: Debug, │ │ │ │ + P: FnMut(&T) -> bool,

    1.51.0 · source§

    impl<T, P> Debug for alloc::slice::SplitInclusive<'_, T, P>
    where │ │ │ │ + T: Debug, │ │ │ │ + P: FnMut(&T) -> bool,

    1.51.0 · source§

    impl<T, P> Debug for SplitInclusiveMut<'_, T, P>
    where │ │ │ │ + T: Debug, │ │ │ │ + P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for SplitMut<'_, T, P>
    where │ │ │ │ + T: Debug, │ │ │ │ + P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for alloc::slice::SplitN<'_, T, P>
    where │ │ │ │ + T: Debug, │ │ │ │ + P: FnMut(&T) -> bool,

    1.9.0 · source§

    impl<T, P> Debug for SplitNMut<'_, T, P>
    where │ │ │ │ + T: Debug, │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    impl<T, const N: usize> Debug for [T; N]
    where │ │ │ │ + T: Debug,

    1.40.0 · source§

    impl<T, const N: usize> Debug for core::array::iter::IntoIter<T, N>
    where │ │ │ │ + T: Debug,

    source§

    impl<T, const N: usize> Debug for Mask<T, N>
    where │ │ │ │ + T: MaskElement + Debug, │ │ │ │ + LaneCount<N>: SupportedLaneCount,

    source§

    impl<T, const N: usize> Debug for Simd<T, N>
    where │ │ │ │ + LaneCount<N>: SupportedLaneCount, │ │ │ │ + T: SimdElement + Debug,

    1.17.0 · source§

    impl<T: Ord + Debug, A: Allocator> Debug for PeekMut<'_, T, A>

    source§

    impl<T: Debug + ?Sized, A: Allocator> Debug for Box<T, A>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::binary_heap::Iter<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::btree_set::Iter<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for SymmetricDifference<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for Union<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::linked_list::Iter<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::linked_list::IterMut<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::vec_deque::Iter<'_, T>

    1.17.0 · source§

    impl<T: Debug> Debug for alloc::collections::vec_deque::IterMut<'_, T>

    source§

    impl<T: Debug> Debug for UniqueRc<T>

    source§

    impl<T: Debug, A: Allocator + Clone> Debug for BTreeSet<T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator + Clone> Debug for Difference<'_, T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator + Clone> Debug for Intersection<'_, T, A>

    1.4.0 · source§

    impl<T: Debug, A: Allocator> Debug for BinaryHeap<T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::binary_heap::IntoIter<T, A>

    source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::linked_list::Cursor<'_, T, A>

    source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::linked_list::CursorMut<'_, T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::linked_list::IntoIter<T, A>

    source§

    impl<T: Debug, A: Allocator> Debug for LinkedList<T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::vec_deque::Drain<'_, T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::collections::vec_deque::IntoIter<T, A>

    source§

    impl<T: Debug, A: Allocator> Debug for VecDeque<T, A>

    1.17.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::vec::Drain<'_, T, A>

    1.13.0 · source§

    impl<T: Debug, A: Allocator> Debug for alloc::vec::IntoIter<T, A>

    source§

    impl<T: Debug, A: Allocator> Debug for Vec<T, A>

    source§

    impl<T: Debug, A: Debug + Allocator + Clone> Debug for alloc::collections::btree_set::IntoIter<T, A>

    source§

    impl<T: Debug, A: Debug + Allocator> Debug for IntoIterSorted<T, A>

    source§

    impl<T: Debug, F> Debug for alloc::collections::linked_list::ExtractIf<'_, T, F>
    where │ │ │ │ + F: FnMut(&mut T) -> bool,

    source§

    impl<T: ?Sized + Debug> Debug for ThinBox<T>

    source§

    impl<T: ?Sized + Debug, A: Allocator> Debug for Rc<T, A>

    source§

    impl<T: ?Sized + Debug, A: Allocator> Debug for Arc<T, A>

    1.4.0 · source§

    impl<T: ?Sized> Debug for alloc::sync::Weak<T>

    1.4.0 · source§

    impl<T: ?Sized, A: Allocator> Debug for alloc::rc::Weak<T, A>

    source§

    impl<Y, R> Debug for CoroutineState<Y, R>
    where │ │ │ │ Y: Debug, │ │ │ │ - R: Debug,

    source§

    impl<const N: usize> Debug for GetManyMutError<N>

    │ │ │ │ + R: Debug,
    source§

    impl<const N: usize> Debug for GetManyMutError<N>

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -121,14 +121,20 @@ │ │ │ │ │ assert_eq!(format!("{position:#?}"), "( │ │ │ │ │ 1.987, │ │ │ │ │ 2.983, │ │ │ │ │ )"); │ │ │ │ │ Run │ │ │ │ │ ***** Implementors§ ***** │ │ │ │ │ source§ │ │ │ │ │ +**** impl Debug for TryReserveErrorKind **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Debug for SearchStep **** │ │ │ │ │ +1.28.0 · source§ │ │ │ │ │ +**** impl Debug for alloc::fmt::Alignment **** │ │ │ │ │ +source§ │ │ │ │ │ **** impl Debug for AsciiChar **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for core::cmp::Ordering **** │ │ │ │ │ 1.34.0 · source§ │ │ │ │ │ **** impl Debug for Infallible **** │ │ │ │ │ 1.16.0 · source§ │ │ │ │ │ **** impl Debug for c_void **** │ │ │ │ │ @@ -141,20 +147,14 @@ │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for FpCategory **** │ │ │ │ │ 1.55.0 · source§ │ │ │ │ │ **** impl Debug for IntErrorKind **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for core::sync::atomic::Ordering **** │ │ │ │ │ source§ │ │ │ │ │ -**** impl Debug for TryReserveErrorKind **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Debug for SearchStep **** │ │ │ │ │ -1.28.0 · source§ │ │ │ │ │ -**** impl Debug for alloc::fmt::Alignment **** │ │ │ │ │ -source§ │ │ │ │ │ **** impl Debug for bool **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for char **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for f32 **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for f64 **** │ │ │ │ │ @@ -185,14 +185,52 @@ │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for u128 **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for () **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for usize **** │ │ │ │ │ source§ │ │ │ │ │ +**** impl Debug for AllocError **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Debug for Global **** │ │ │ │ │ +1.28.0 · source§ │ │ │ │ │ +**** impl Debug for Layout **** │ │ │ │ │ +1.50.0 · source§ │ │ │ │ │ +**** impl Debug for LayoutError **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Debug for UnorderedKeyError **** │ │ │ │ │ +1.57.0 · source§ │ │ │ │ │ +**** impl Debug for TryReserveError **** │ │ │ │ │ +1.64.0 · source§ │ │ │ │ │ +**** impl Debug for FromVecWithNulError **** │ │ │ │ │ +1.64.0 · source§ │ │ │ │ │ +**** impl Debug for IntoStringError **** │ │ │ │ │ +1.64.0 · source§ │ │ │ │ │ +**** impl Debug for NulError **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Debug for CString **** │ │ │ │ │ +1.38.0 · source§ │ │ │ │ │ +**** impl Debug for Chars<'_> **** │ │ │ │ │ +1.17.0 · source§ │ │ │ │ │ +**** impl Debug for EncodeUtf16<'_> **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Debug for ParseBoolError **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Debug for Utf8Chunks<'_> **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Debug for Utf8Error **** │ │ │ │ │ +1.17.0 · source§ │ │ │ │ │ +**** impl Debug for alloc::string::Drain<'_> **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Debug for FromUtf8Error **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Debug for FromUtf16Error **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Debug for String **** │ │ │ │ │ +source§ │ │ │ │ │ **** impl Debug for TypeId **** │ │ │ │ │ 1.34.0 · source§ │ │ │ │ │ **** impl Debug for TryFromSliceError **** │ │ │ │ │ 1.16.0 · source§ │ │ │ │ │ **** impl Debug for core::ascii::EscapeDefault **** │ │ │ │ │ 1.13.0 · source§ │ │ │ │ │ **** impl Debug for BorrowError **** │ │ │ │ │ @@ -311,75 +349,23 @@ │ │ │ │ │ 1.36.0 · source§ │ │ │ │ │ **** impl Debug for Waker **** │ │ │ │ │ 1.27.0 · source§ │ │ │ │ │ **** impl Debug for Duration **** │ │ │ │ │ 1.66.0 · source§ │ │ │ │ │ **** impl Debug for TryFromFloatSecsError **** │ │ │ │ │ source§ │ │ │ │ │ -**** impl Debug for AllocError **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Debug for Global **** │ │ │ │ │ -1.28.0 · source§ │ │ │ │ │ -**** impl Debug for Layout **** │ │ │ │ │ -1.50.0 · source§ │ │ │ │ │ -**** impl Debug for LayoutError **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Debug for UnorderedKeyError **** │ │ │ │ │ -1.57.0 · source§ │ │ │ │ │ -**** impl Debug for TryReserveError **** │ │ │ │ │ -1.64.0 · source§ │ │ │ │ │ -**** impl Debug for FromVecWithNulError **** │ │ │ │ │ -1.64.0 · source§ │ │ │ │ │ -**** impl Debug for IntoStringError **** │ │ │ │ │ -1.64.0 · source§ │ │ │ │ │ -**** impl Debug for NulError **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Debug for CString **** │ │ │ │ │ -1.38.0 · source§ │ │ │ │ │ -**** impl Debug for Chars<'_> **** │ │ │ │ │ -1.17.0 · source§ │ │ │ │ │ -**** impl Debug for EncodeUtf16<'_> **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Debug for ParseBoolError **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Debug for Utf8Chunks<'_> **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Debug for Utf8Error **** │ │ │ │ │ -1.17.0 · source§ │ │ │ │ │ -**** impl Debug for alloc::string::Drain<'_> **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Debug for FromUtf8Error **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Debug for FromUtf16Error **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Debug for String **** │ │ │ │ │ -source§ │ │ │ │ │ **** impl Debug for Arguments<'_> **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for Error **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for dyn Any **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Debug for dyn Any + Send **** │ │ │ │ │ 1.28.0 · source§ │ │ │ │ │ **** impl Debug for dyn Any + Sync + Send **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl<'a> Debug for Request<'a> **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl<'a> Debug for Source<'a> **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl<'a> Debug for core::ffi::c_str::Bytes<'a> **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl<'a> Debug for BorrowedCursor<'a> **** │ │ │ │ │ -1.10.0 · source§ │ │ │ │ │ -**** impl<'a> Debug for Location<'a> **** │ │ │ │ │ -1.10.0 · source§ │ │ │ │ │ -**** impl<'a> Debug for PanicInfo<'a> **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl<'a> Debug for ContextBuilder<'a> **** │ │ │ │ │ 1.60.0 · source§ │ │ │ │ │ **** impl<'a> Debug for EscapeAscii<'a> **** │ │ │ │ │ source§ │ │ │ │ │ **** impl<'a> Debug for CharSearcher<'a> **** │ │ │ │ │ source§ │ │ │ │ │ **** impl<'a> Debug for alloc::str::Bytes<'a> **** │ │ │ │ │ source§ │ │ │ │ │ @@ -397,14 +383,28 @@ │ │ │ │ │ 1.34.0 · source§ │ │ │ │ │ **** impl<'a> Debug for SplitAsciiWhitespace<'a> **** │ │ │ │ │ 1.1.0 · source§ │ │ │ │ │ **** impl<'a> Debug for SplitWhitespace<'a> **** │ │ │ │ │ source§ │ │ │ │ │ **** impl<'a> Debug for Utf8Chunk<'a> **** │ │ │ │ │ source§ │ │ │ │ │ +**** impl<'a> Debug for Request<'a> **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl<'a> Debug for Source<'a> **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl<'a> Debug for core::ffi::c_str::Bytes<'a> **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl<'a> Debug for BorrowedCursor<'a> **** │ │ │ │ │ +1.10.0 · source§ │ │ │ │ │ +**** impl<'a> Debug for Location<'a> **** │ │ │ │ │ +1.10.0 · source§ │ │ │ │ │ +**** impl<'a> Debug for PanicInfo<'a> **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl<'a> Debug for ContextBuilder<'a> **** │ │ │ │ │ +source§ │ │ │ │ │ **** impl<'a, 'b> Debug for CharSliceSearcher<'a, 'b> **** │ │ │ │ │ source§ │ │ │ │ │ **** impl<'a, 'b> Debug for StrSearcher<'a, 'b> **** │ │ │ │ │ source§ │ │ │ │ │ **** impl<'a, 'b, const N: usize> Debug for CharArrayRefSearcher<'a, 'b, N> │ │ │ │ │ **** │ │ │ │ │ source§ │ │ │ │ │ @@ -453,20 +453,14 @@ │ │ │ │ │ source§ │ │ │ │ │ impl<'a, P> Debug for alloc::str::SplitN<'a, P> │ │ │ │ │ where P: Pattern<'a>,

    >::Searcher: Debug, │ │ │ │ │ source§ │ │ │ │ │ impl<'a, P> Debug for SplitTerminator<'a, P> │ │ │ │ │ where P: Pattern<'a>,

    >::Searcher: Debug, │ │ │ │ │ source§ │ │ │ │ │ -impl<'a, T> Debug for core::result::Iter<'a, T> │ │ │ │ │ -where T: Debug + 'a, │ │ │ │ │ -source§ │ │ │ │ │ -impl<'a, T> Debug for core::result::IterMut<'a, T> │ │ │ │ │ -where T: Debug + 'a, │ │ │ │ │ -source§ │ │ │ │ │ impl<'a, T> Debug for Chunks<'a, T> │ │ │ │ │ where T: Debug + 'a, │ │ │ │ │ 1.31.0 · source§ │ │ │ │ │ impl<'a, T> Debug for ChunksExact<'a, T> │ │ │ │ │ where T: Debug + 'a, │ │ │ │ │ 1.31.0 · source§ │ │ │ │ │ impl<'a, T> Debug for ChunksExactMut<'a, T> │ │ │ │ │ @@ -485,14 +479,20 @@ │ │ │ │ │ where T: Debug + 'a, │ │ │ │ │ 1.31.0 · source§ │ │ │ │ │ impl<'a, T> Debug for RChunksMut<'a, T> │ │ │ │ │ where T: Debug + 'a, │ │ │ │ │ source§ │ │ │ │ │ impl<'a, T> Debug for Windows<'a, T> │ │ │ │ │ where T: Debug + 'a, │ │ │ │ │ +source§ │ │ │ │ │ +impl<'a, T> Debug for core::result::Iter<'a, T> │ │ │ │ │ +where T: Debug + 'a, │ │ │ │ │ +source§ │ │ │ │ │ +impl<'a, T> Debug for core::result::IterMut<'a, T> │ │ │ │ │ +where T: Debug + 'a, │ │ │ │ │ 1.77.0 · source§ │ │ │ │ │ impl<'a, T, P> Debug for ChunkBy<'a, T, P> │ │ │ │ │ where T: 'a + Debug, │ │ │ │ │ 1.77.0 · source§ │ │ │ │ │ impl<'a, T, P> Debug for ChunkByMut<'a, T, P> │ │ │ │ │ where T: 'a + Debug, │ │ │ │ │ source§ │ │ │ │ │ @@ -541,26 +541,26 @@ │ │ │ │ │ where B: Debug + ToOwned + ?Sized, │ │ │ │ │ 1.55.0 · source§ │ │ │ │ │ impl Debug for ControlFlow │ │ │ │ │ where B: Debug, C: Debug, │ │ │ │ │ source§ │ │ │ │ │ impl Debug for DynMetadata │ │ │ │ │ where Dyn: ?Sized, │ │ │ │ │ +source§ │ │ │ │ │ +impl Debug for CharPredicateSearcher<'_, F> │ │ │ │ │ +where F: FnMut(char) -> bool, │ │ │ │ │ 1.64.0 · source§ │ │ │ │ │ **** impl Debug for PollFn **** │ │ │ │ │ 1.34.0 · source§ │ │ │ │ │ **** impl Debug for FromFn **** │ │ │ │ │ 1.68.0 · source§ │ │ │ │ │ **** impl Debug for OnceWith **** │ │ │ │ │ 1.68.0 · source§ │ │ │ │ │ **** impl Debug for RepeatWith **** │ │ │ │ │ source§ │ │ │ │ │ -impl Debug for CharPredicateSearcher<'_, F> │ │ │ │ │ -where F: FnMut(char) -> bool, │ │ │ │ │ -source§ │ │ │ │ │ impl Debug for FormatterFn │ │ │ │ │ where F: Fn(&mut Formatter<'_>) -> Result<(), Error>, │ │ │ │ │ 1.4.0 · source§ │ │ │ │ │ impl Debug for F │ │ │ │ │ where F: FnPtr, │ │ │ │ │ 1.9.0 · source§ │ │ │ │ │ **** impl Debug for BuildHasherDefault **** │ │ │ │ │ @@ -733,14 +733,20 @@ │ │ │ │ │ source§ │ │ │ │ │ impl Debug for [T] │ │ │ │ │ where T: Debug, │ │ │ │ │ source§ │ │ │ │ │ impl Debug for (T₁,_T₂,_…,_Tₙ) │ │ │ │ │ where T: Debug + ?Sized, │ │ │ │ │ This trait is implemented for tuples up to twelve items long. │ │ │ │ │ +1.9.0 · source§ │ │ │ │ │ +impl Debug for alloc::slice::Iter<'_, T> │ │ │ │ │ +where T: Debug, │ │ │ │ │ +1.9.0 · source§ │ │ │ │ │ +impl Debug for alloc::slice::IterMut<'_, T> │ │ │ │ │ +where T: Debug, │ │ │ │ │ 1.70.0 · source§ │ │ │ │ │ impl Debug for OnceCell │ │ │ │ │ where T: Debug, │ │ │ │ │ source§ │ │ │ │ │ impl Debug for Cell │ │ │ │ │ where T: Copy + Debug, │ │ │ │ │ source§ │ │ │ │ │ @@ -804,20 +810,14 @@ │ │ │ │ │ impl Debug for core::result::IntoIter │ │ │ │ │ where T: Debug, │ │ │ │ │ 1.3.0 · source§ │ │ │ │ │ **** impl Debug for AtomicPtr **** │ │ │ │ │ source§ │ │ │ │ │ impl Debug for Exclusive │ │ │ │ │ where T: ?Sized, │ │ │ │ │ -1.9.0 · source§ │ │ │ │ │ -impl Debug for alloc::slice::Iter<'_, T> │ │ │ │ │ -where T: Debug, │ │ │ │ │ -1.9.0 · source§ │ │ │ │ │ -impl Debug for alloc::slice::IterMut<'_, T> │ │ │ │ │ -where T: Debug, │ │ │ │ │ 1.41.0 · source§ │ │ │ │ │ **** impl Debug for MaybeUninit **** │ │ │ │ │ source§ │ │ │ │ │ impl Debug for Result │ │ │ │ │ where T: Debug, E: Debug, │ │ │ │ │ source§ │ │ │ │ │ impl Debug for LazyCell │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Display.html │ │ │ │ @@ -1,11 +1,11 @@ │ │ │ │ Display in alloc::fmt - Rust

    │ │ │ │ -

    Trait alloc::fmt::Display

    1.0.0 · source · 
    pub trait Display {
│ │ │ │ +    
    Trait alloc::fmt::Display
    1.0.0 · source · 
    pub trait Display {
│ │ │ │      // Required method
│ │ │ │ -    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │ +    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │  }
    Expand description
    Format trait for an empty format, {}.
    
│ │ │ │  
    Implementing this trait for a type will automatically implement the
│ │ │ │  ToString trait for the type, allowing the usage
│ │ │ │  of the .to_string() method. Prefer implementing
│ │ │ │  the Display trait for a type, rather than ToString.
    
│ │ │ │  
    Display is similar to Debug, but Display is for user-facing
│ │ │ │  output, and so cannot be derived.
    
│ │ │ │ @@ -15,15 +15,15 @@
│ │ │ │  to only implement Display when there is a single most “obvious” way that
│ │ │ │  values can be formatted as text. This could mean formatting according to the
│ │ │ │  “invariant” culture and “undefined” locale, or it could mean that the type
│ │ │ │  display is designed for a specific culture/locale, such as developer logs.
    
│ │ │ │  
    If not all values have a justifiably canonical textual format or if you want
│ │ │ │  to support alternative formats not covered by the standard set of possible
│ │ │ │  formatting traits, the most flexible approach is display adapters: methods
│ │ │ │ -like str::escape_default or Path::display which create a wrapper
│ │ │ │ +like str::escape_default or Path::display which create a wrapper
│ │ │ │  implementing Display to output the specific display format.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Implementing Display on a type:
    
│ │ │ │  
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Point {
│ │ │ │ @@ -36,15 +36,15 @@
│ │ │ │          write!(f, "({}, {})", self.x, self.y)
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  let origin = Point { x: 0, y: 0 };
│ │ │ │  
│ │ │ │  assert_eq!(format!("The origin is: {origin}"), "The origin is: (0, 0)");
    Run
    
│ │ │ │ -
    Required Methods§
    source
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter.
    
│ │ │ │ +
    Required Methods§
    source
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::fmt;
│ │ │ │  
│ │ │ │  struct Position {
│ │ │ │      longitude: f32,
│ │ │ │      latitude: f32,
│ │ │ │  }
│ │ │ │ @@ -53,20 +53,20 @@
│ │ │ │      fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
│ │ │ │          write!(f, "({}, {})", self.longitude, self.latitude)
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!("(1.987, 2.983)",
│ │ │ │             format!("{}", Position { longitude: 1.987, latitude: 2.983, }));
    Run
    
│ │ │ │ -
    Implementors§
    source§
    impl Display for AsciiChar
    1.34.0 · source§
    impl Display for Infallible
    1.7.0 · source§
    impl Display for IpAddr
    source§
    impl Display for SocketAddr
    source§
    impl Display for bool
    source§
    impl Display for char
    source§
    impl Display for f32
    source§
    impl Display for f64
    source§
    impl Display for i8
    source§
    impl Display for i16
    source§
    impl Display for i32
    source§
    impl Display for i64
    source§
    impl Display for i128
    source§
    impl Display for isize
    source§
    impl Display for !
    source§
    impl Display for str
    source§
    impl Display for u8
    source§
    impl Display for u16
    source§
    impl Display for u32
    source§
    impl Display for u64
    source§
    impl Display for u128
    source§
    impl Display for usize
    1.36.0 · source§
    impl Display for TryFromSliceError
    1.39.0 · source§
    impl Display for core::ascii::EscapeDefault
    1.13.0 · source§
    impl Display for BorrowError
    1.13.0 · source§
    impl Display for BorrowMutError
    1.34.0 · source§
    impl Display for CharTryFromError
    1.20.0 · source§
    impl Display for ParseCharError
    1.9.0 · source§
    impl Display for DecodeUtf16Error
    1.20.0 · source§
    impl Display for core::char::EscapeDebug
    1.16.0 · source§
    impl Display for core::char::EscapeDefault
    1.16.0 · source§
    impl Display for core::char::EscapeUnicode
    1.16.0 · source§
    impl Display for ToLowercase
    1.16.0 · source§
    impl Display for ToUppercase
    1.59.0 · source§
    impl Display for TryFromCharError
    1.69.0 · source§
    impl Display for FromBytesUntilNulError
    1.17.0 · source§
    impl Display for FromBytesWithNulError
    source§
    impl Display for Ipv4Addr
    source§
    impl Display for Ipv6Addr
    Write an Ipv6Addr, conforming to the canonical style described by
│ │ │ │ +
    Implementors§
    source§
    impl Display for AsciiChar
    1.34.0 · source§
    impl Display for Infallible
    1.7.0 · source§
    impl Display for IpAddr
    source§
    impl Display for SocketAddr
    source§
    impl Display for bool
    source§
    impl Display for char
    source§
    impl Display for f32
    source§
    impl Display for f64
    source§
    impl Display for i8
    source§
    impl Display for i16
    source§
    impl Display for i32
    source§
    impl Display for i64
    source§
    impl Display for i128
    source§
    impl Display for isize
    source§
    impl Display for !
    source§
    impl Display for str
    source§
    impl Display for u8
    source§
    impl Display for u16
    source§
    impl Display for u32
    source§
    impl Display for u64
    source§
    impl Display for u128
    source§
    impl Display for usize
    source§
    impl Display for AllocError
    1.28.0 · source§
    impl Display for LayoutError
    source§
    impl Display for UnorderedKeyError
    1.57.0 · source§
    impl Display for TryReserveError
    1.58.0 · source§
    impl Display for FromVecWithNulError
    1.7.0 · source§
    impl Display for IntoStringError
    source§
    impl Display for NulError
    source§
    impl Display for ParseBoolError
    source§
    impl Display for Utf8Error
    source§
    impl Display for FromUtf8Error
    source§
    impl Display for FromUtf16Error
    source§
    impl Display for String
    1.36.0 · source§
    impl Display for TryFromSliceError
    1.39.0 · source§
    impl Display for core::ascii::EscapeDefault
    1.13.0 · source§
    impl Display for BorrowError
    1.13.0 · source§
    impl Display for BorrowMutError
    1.34.0 · source§
    impl Display for CharTryFromError
    1.20.0 · source§
    impl Display for ParseCharError
    1.9.0 · source§
    impl Display for DecodeUtf16Error
    1.20.0 · source§
    impl Display for core::char::EscapeDebug
    1.16.0 · source§
    impl Display for core::char::EscapeDefault
    1.16.0 · source§
    impl Display for core::char::EscapeUnicode
    1.16.0 · source§
    impl Display for ToLowercase
    1.16.0 · source§
    impl Display for ToUppercase
    1.59.0 · source§
    impl Display for TryFromCharError
    1.69.0 · source§
    impl Display for FromBytesUntilNulError
    1.17.0 · source§
    impl Display for FromBytesWithNulError
    source§
    impl Display for Ipv4Addr
    source§
    impl Display for Ipv6Addr
    Write an Ipv6Addr, conforming to the canonical style described by
│ │ │ │  RFC 5952.
    
│ │ │ │ -
    1.4.0 · source§
    impl Display for AddrParseError
    source§
    impl Display for SocketAddrV4
    source§
    impl Display for SocketAddrV6
    source§
    impl Display for ParseFloatError
    source§
    impl Display for ParseIntError
    1.34.0 · source§
    impl Display for TryFromIntError
    1.26.0 · source§
    impl Display for Location<'_>
    1.26.0 · source§
    impl Display for PanicInfo<'_>
    1.66.0 · source§
    impl Display for TryFromFloatSecsError
    source§
    impl Display for AllocError
    1.28.0 · source§
    impl Display for LayoutError
    source§
    impl Display for UnorderedKeyError
    1.57.0 · source§
    impl Display for TryReserveError
    1.58.0 · source§
    impl Display for FromVecWithNulError
    1.7.0 · source§
    impl Display for IntoStringError
    source§
    impl Display for NulError
    source§
    impl Display for ParseBoolError
    source§
    impl Display for Utf8Error
    source§
    impl Display for FromUtf8Error
    source§
    impl Display for FromUtf16Error
    source§
    impl Display for String
    source§
    impl Display for Arguments<'_>
    source§
    impl Display for Error
    1.60.0 · source§
    impl<'a> Display for EscapeAscii<'a>
    1.34.0 · source§
    impl<'a> Display for alloc::str::EscapeDebug<'a>
    1.34.0 · source§
    impl<'a> Display for alloc::str::EscapeDefault<'a>
    1.34.0 · source§
    impl<'a> Display for alloc::str::EscapeUnicode<'a>
    source§
    impl<'a, K: Debug + Ord, V: Debug, A: Allocator + Clone> Display for OccupiedError<'a, K, V, A>
    source§
    impl<B> Display for Cow<'_, B>
    where
│ │ │ │ -    B: Display + ToOwned<Owned: Display> + ?Sized,
    source§
    impl<F> Display for FormatterFn<F>
    where
│ │ │ │ -    F: Fn(&mut Formatter<'_>) -> Result<(), Error>,
    1.33.0 · source§
    impl<Ptr> Display for Pin<Ptr>
    where
│ │ │ │ -    Ptr: Display,
    source§
    impl<T> Display for &T
    where
│ │ │ │ -    T: Display + ?Sized,
    source§
    impl<T> Display for &mut T
    where
│ │ │ │ -    T: Display + ?Sized,
    1.20.0 · source§
    impl<T> Display for Ref<'_, T>
    where
│ │ │ │ -    T: Display + ?Sized,
    1.20.0 · source§
    impl<T> Display for RefMut<'_, T>
    where
│ │ │ │ -    T: Display + ?Sized,
    1.28.0 · source§
    impl<T> Display for NonZero<T>
    where
│ │ │ │ -    T: ZeroablePrimitive + Display,
    1.74.0 · source§
    impl<T> Display for Saturating<T>
    where
│ │ │ │ -    T: Display,
    1.10.0 · source§
    impl<T> Display for Wrapping<T>
    where
│ │ │ │ -    T: Display,
    source§
    impl<T: Display + ?Sized, A: Allocator> Display for Box<T, A>
    source§
    impl<T: ?Sized + Display> Display for ThinBox<T>
    source§
    impl<T: ?Sized + Display, A: Allocator> Display for Rc<T, A>
    source§
    impl<T: ?Sized + Display, A: Allocator> Display for Arc<T, A>
    source§
    impl<const N: usize> Display for GetManyMutError<N>
    
│ │ │ │ +
    1.4.0 · source§

    impl Display for AddrParseError

    source§

    impl Display for SocketAddrV4

    source§

    impl Display for SocketAddrV6

    source§

    impl Display for ParseFloatError

    source§

    impl Display for ParseIntError

    1.34.0 · source§

    impl Display for TryFromIntError

    1.26.0 · source§

    impl Display for Location<'_>

    1.26.0 · source§

    impl Display for PanicInfo<'_>

    1.66.0 · source§

    impl Display for TryFromFloatSecsError

    source§

    impl Display for Arguments<'_>

    source§

    impl Display for Error

    1.60.0 · source§

    impl<'a> Display for EscapeAscii<'a>

    1.34.0 · source§

    impl<'a> Display for alloc::str::EscapeDebug<'a>

    1.34.0 · source§

    impl<'a> Display for alloc::str::EscapeDefault<'a>

    1.34.0 · source§

    impl<'a> Display for alloc::str::EscapeUnicode<'a>

    source§

    impl<'a, K: Debug + Ord, V: Debug, A: Allocator + Clone> Display for OccupiedError<'a, K, V, A>

    source§

    impl<B> Display for Cow<'_, B>
    where │ │ │ │ + B: Display + ToOwned<Owned: Display> + ?Sized,

    source§

    impl<F> Display for FormatterFn<F>
    where │ │ │ │ + F: Fn(&mut Formatter<'_>) -> Result<(), Error>,

    1.33.0 · source§

    impl<Ptr> Display for Pin<Ptr>
    where │ │ │ │ + Ptr: Display,

    source§

    impl<T> Display for &T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    impl<T> Display for &mut T
    where │ │ │ │ + T: Display + ?Sized,

    1.20.0 · source§

    impl<T> Display for Ref<'_, T>
    where │ │ │ │ + T: Display + ?Sized,

    1.20.0 · source§

    impl<T> Display for RefMut<'_, T>
    where │ │ │ │ + T: Display + ?Sized,

    1.28.0 · source§

    impl<T> Display for NonZero<T>
    where │ │ │ │ + T: ZeroablePrimitive + Display,

    1.74.0 · source§

    impl<T> Display for Saturating<T>
    where │ │ │ │ + T: Display,

    1.10.0 · source§

    impl<T> Display for Wrapping<T>
    where │ │ │ │ + T: Display,

    source§

    impl<T: Display + ?Sized, A: Allocator> Display for Box<T, A>

    source§

    impl<T: ?Sized + Display> Display for ThinBox<T>

    source§

    impl<T: ?Sized + Display, A: Allocator> Display for Rc<T, A>

    source§

    impl<T: ?Sized + Display, A: Allocator> Display for Arc<T, A>

    source§

    impl<const N: usize> Display for GetManyMutError<N>

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -114,14 +114,38 @@ │ │ │ │ │ **** impl Display for u32 **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Display for u64 **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Display for u128 **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Display for usize **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Display for AllocError **** │ │ │ │ │ +1.28.0 · source§ │ │ │ │ │ +**** impl Display for LayoutError **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Display for UnorderedKeyError **** │ │ │ │ │ +1.57.0 · source§ │ │ │ │ │ +**** impl Display for TryReserveError **** │ │ │ │ │ +1.58.0 · source§ │ │ │ │ │ +**** impl Display for FromVecWithNulError **** │ │ │ │ │ +1.7.0 · source§ │ │ │ │ │ +**** impl Display for IntoStringError **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Display for NulError **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Display for ParseBoolError **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Display for Utf8Error **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Display for FromUtf8Error **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Display for FromUtf16Error **** │ │ │ │ │ +source§ │ │ │ │ │ +**** impl Display for String **** │ │ │ │ │ 1.36.0 · source§ │ │ │ │ │ **** impl Display for TryFromSliceError **** │ │ │ │ │ 1.39.0 · source§ │ │ │ │ │ **** impl Display for core::ascii::EscapeDefault **** │ │ │ │ │ 1.13.0 · source§ │ │ │ │ │ **** impl Display for BorrowError **** │ │ │ │ │ 1.13.0 · source§ │ │ │ │ │ @@ -168,38 +192,14 @@ │ │ │ │ │ 1.26.0 · source§ │ │ │ │ │ **** impl Display for Location<'_> **** │ │ │ │ │ 1.26.0 · source§ │ │ │ │ │ **** impl Display for PanicInfo<'_> **** │ │ │ │ │ 1.66.0 · source§ │ │ │ │ │ **** impl Display for TryFromFloatSecsError **** │ │ │ │ │ source§ │ │ │ │ │ -**** impl Display for AllocError **** │ │ │ │ │ -1.28.0 · source§ │ │ │ │ │ -**** impl Display for LayoutError **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Display for UnorderedKeyError **** │ │ │ │ │ -1.57.0 · source§ │ │ │ │ │ -**** impl Display for TryReserveError **** │ │ │ │ │ -1.58.0 · source§ │ │ │ │ │ -**** impl Display for FromVecWithNulError **** │ │ │ │ │ -1.7.0 · source§ │ │ │ │ │ -**** impl Display for IntoStringError **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Display for NulError **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Display for ParseBoolError **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Display for Utf8Error **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Display for FromUtf8Error **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Display for FromUtf16Error **** │ │ │ │ │ -source§ │ │ │ │ │ -**** impl Display for String **** │ │ │ │ │ -source§ │ │ │ │ │ **** impl Display for Arguments<'_> **** │ │ │ │ │ source§ │ │ │ │ │ **** impl Display for Error **** │ │ │ │ │ 1.60.0 · source§ │ │ │ │ │ **** impl<'a> Display for EscapeAscii<'a> **** │ │ │ │ │ 1.34.0 · source§ │ │ │ │ │ **** impl<'a> Display for alloc::str::EscapeDebug<'a> **** │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.LowerExp.html │ │ │ │ @@ -1,11 +1,11 @@ │ │ │ │ LowerExp in alloc::fmt - Rust
    │ │ │ │ -

    Trait alloc::fmt::LowerExp

    1.0.0 · source · 
    pub trait LowerExp {
│ │ │ │ +    
    Trait alloc::fmt::LowerExp
    1.0.0 · source · 
    pub trait LowerExp {
│ │ │ │      // Required method
│ │ │ │ -    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │ +    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │  }
    Expand description
    e formatting.
    
│ │ │ │  
    The LowerExp trait should format its output in scientific notation with a lower-case e.
    
│ │ │ │  
    For more information on formatters, see the module-level documentation.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage with f64:
    
│ │ │ │  
│ │ │ │  
    let x = 42.0; // 42.0 is '4.2e1' in scientific notation
│ │ │ │ @@ -31,11 +31,11 @@
│ │ │ │      "l in scientific notation is: 1e2"
│ │ │ │  );
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("l in scientific notation is: {l:05e}"),
│ │ │ │      "l in scientific notation is: 001e2"
│ │ │ │  );
    Run
    
│ │ │ │ -
    Required Methods§
    source
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter.
    
│ │ │ │ -
    Implementors§
    source§
    impl LowerExp for f32
    source§
    impl LowerExp for f64
    1.42.0 · source§
    impl LowerExp for i8
    1.42.0 · source§
    impl LowerExp for i16
    1.42.0 · source§
    impl LowerExp for i32
    1.42.0 · source§
    impl LowerExp for i64
    1.42.0 · source§
    impl LowerExp for i128
    1.42.0 · source§
    impl LowerExp for isize
    1.42.0 · source§
    impl LowerExp for u8
    1.42.0 · source§
    impl LowerExp for u16
    1.42.0 · source§
    impl LowerExp for u32
    1.42.0 · source§
    impl LowerExp for u64
    1.42.0 · source§
    impl LowerExp for u128
    1.42.0 · source§
    impl LowerExp for usize
    source§
    impl<T> LowerExp for &T
    where
│ │ │ │ -    T: LowerExp + ?Sized,
    source§
    impl<T> LowerExp for &mut T
    where
│ │ │ │ -    T: LowerExp + ?Sized,
    
│ │ │ │ +

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ +

    Implementors§

    source§

    impl LowerExp for f32

    source§

    impl LowerExp for f64

    1.42.0 · source§

    impl LowerExp for i8

    1.42.0 · source§

    impl LowerExp for i16

    1.42.0 · source§

    impl LowerExp for i32

    1.42.0 · source§

    impl LowerExp for i64

    1.42.0 · source§

    impl LowerExp for i128

    1.42.0 · source§

    impl LowerExp for isize

    1.42.0 · source§

    impl LowerExp for u8

    1.42.0 · source§

    impl LowerExp for u16

    1.42.0 · source§

    impl LowerExp for u32

    1.42.0 · source§

    impl LowerExp for u64

    1.42.0 · source§

    impl LowerExp for u128

    1.42.0 · source§

    impl LowerExp for usize

    source§

    impl<T> LowerExp for &T
    where │ │ │ │ + T: LowerExp + ?Sized,

    source§

    impl<T> LowerExp for &mut T
    where │ │ │ │ + T: LowerExp + ?Sized,

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.LowerHex.html │ │ │ │ @@ -1,11 +1,11 @@ │ │ │ │ LowerHex in alloc::fmt - Rust
    │ │ │ │ -

    Trait alloc::fmt::LowerHex

    1.0.0 · source · 
    pub trait LowerHex {
│ │ │ │ +    
    Trait alloc::fmt::LowerHex
    1.0.0 · source · 
    pub trait LowerHex {
│ │ │ │      // Required method
│ │ │ │ -    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │ +    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │  }
    Expand description
    x formatting.
    
│ │ │ │  
    The LowerHex trait should format its output as a number in hexadecimal, with a through f
│ │ │ │  in lower case.
    
│ │ │ │  
    For primitive signed integers (i8 to i128, and isize),
│ │ │ │  negative values are formatted as the two’s complement representation.
    
│ │ │ │  
    The alternate flag, #, adds a 0x in front of the output.
    
│ │ │ │  
    For more information on formatters, see the module-level documentation.
    
│ │ │ │ @@ -33,14 +33,14 @@
│ │ │ │  }
│ │ │ │  
│ │ │ │  let l = Length(9);
│ │ │ │  
│ │ │ │  assert_eq!(format!("l as hex is: {l:x}"), "l as hex is: 9");
│ │ │ │  
│ │ │ │  assert_eq!(format!("l as hex is: {l:#010x}"), "l as hex is: 0x00000009");
    Run
    │ │ │ │ -

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ -

    Implementors§

    source§

    impl LowerHex for i8

    source§

    impl LowerHex for i16

    source§

    impl LowerHex for i32

    source§

    impl LowerHex for i64

    source§

    impl LowerHex for i128

    source§

    impl LowerHex for isize

    source§

    impl LowerHex for u8

    source§

    impl LowerHex for u16

    source§

    impl LowerHex for u32

    source§

    impl LowerHex for u64

    source§

    impl LowerHex for u128

    source§

    impl LowerHex for usize

    source§

    impl<T> LowerHex for &T
    where │ │ │ │ - T: LowerHex + ?Sized,

    source§

    impl<T> LowerHex for &mut T
    where │ │ │ │ - T: LowerHex + ?Sized,

    1.28.0 · source§

    impl<T> LowerHex for NonZero<T>
    where │ │ │ │ - T: ZeroablePrimitive + LowerHex,

    1.74.0 · source§

    impl<T> LowerHex for Saturating<T>
    where │ │ │ │ - T: LowerHex,

    1.11.0 · source§

    impl<T> LowerHex for Wrapping<T>
    where │ │ │ │ +

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ +

    Implementors§

    source§

    impl LowerHex for i8

    source§

    impl LowerHex for i16

    source§

    impl LowerHex for i32

    source§

    impl LowerHex for i64

    source§

    impl LowerHex for i128

    source§

    impl LowerHex for isize

    source§

    impl LowerHex for u8

    source§

    impl LowerHex for u16

    source§

    impl LowerHex for u32

    source§

    impl LowerHex for u64

    source§

    impl LowerHex for u128

    source§

    impl LowerHex for usize

    source§

    impl<T> LowerHex for &T
    where │ │ │ │ + T: LowerHex + ?Sized,

    source§

    impl<T> LowerHex for &mut T
    where │ │ │ │ + T: LowerHex + ?Sized,

    1.28.0 · source§

    impl<T> LowerHex for NonZero<T>
    where │ │ │ │ + T: ZeroablePrimitive + LowerHex,

    1.74.0 · source§

    impl<T> LowerHex for Saturating<T>
    where │ │ │ │ + T: LowerHex,

    1.11.0 · source§

    impl<T> LowerHex for Wrapping<T>
    where │ │ │ │ T: LowerHex,

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Octal.html │ │ │ │ @@ -1,11 +1,11 @@ │ │ │ │ Octal in alloc::fmt - Rust
    │ │ │ │ -

    Trait alloc::fmt::Octal

    1.0.0 · source · 
    pub trait Octal {
│ │ │ │ +    
    Trait alloc::fmt::Octal
    1.0.0 · source · 
    pub trait Octal {
│ │ │ │      // Required method
│ │ │ │ -    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │ +    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │  }
    Expand description
    o formatting.
    
│ │ │ │  
    The Octal trait should format its output as a number in base-8.
    
│ │ │ │  
    For primitive signed integers (i8 to i128, and isize),
│ │ │ │  negative values are formatted as the two’s complement representation.
    
│ │ │ │  
    The alternate flag, #, adds a 0o in front of the output.
    
│ │ │ │  
    For more information on formatters, see the module-level documentation.
    
│ │ │ │  
    §Examples
    
│ │ │ │ @@ -32,14 +32,14 @@
│ │ │ │  }
│ │ │ │  
│ │ │ │  let l = Length(9);
│ │ │ │  
│ │ │ │  assert_eq!(format!("l as octal is: {l:o}"), "l as octal is: 11");
│ │ │ │  
│ │ │ │  assert_eq!(format!("l as octal is: {l:#06o}"), "l as octal is: 0o0011");
    Run
    │ │ │ │ -

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ -

    Implementors§

    source§

    impl Octal for i8

    source§

    impl Octal for i16

    source§

    impl Octal for i32

    source§

    impl Octal for i64

    source§

    impl Octal for i128

    source§

    impl Octal for isize

    source§

    impl Octal for u8

    source§

    impl Octal for u16

    source§

    impl Octal for u32

    source§

    impl Octal for u64

    source§

    impl Octal for u128

    source§

    impl Octal for usize

    source§

    impl<T> Octal for &T
    where │ │ │ │ - T: Octal + ?Sized,

    source§

    impl<T> Octal for &mut T
    where │ │ │ │ - T: Octal + ?Sized,

    1.28.0 · source§

    impl<T> Octal for NonZero<T>
    where │ │ │ │ - T: ZeroablePrimitive + Octal,

    1.74.0 · source§

    impl<T> Octal for Saturating<T>
    where │ │ │ │ - T: Octal,

    1.11.0 · source§

    impl<T> Octal for Wrapping<T>
    where │ │ │ │ +

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ +

    Implementors§

    source§

    impl Octal for i8

    source§

    impl Octal for i16

    source§

    impl Octal for i32

    source§

    impl Octal for i64

    source§

    impl Octal for i128

    source§

    impl Octal for isize

    source§

    impl Octal for u8

    source§

    impl Octal for u16

    source§

    impl Octal for u32

    source§

    impl Octal for u64

    source§

    impl Octal for u128

    source§

    impl Octal for usize

    source§

    impl<T> Octal for &T
    where │ │ │ │ + T: Octal + ?Sized,

    source§

    impl<T> Octal for &mut T
    where │ │ │ │ + T: Octal + ?Sized,

    1.28.0 · source§

    impl<T> Octal for NonZero<T>
    where │ │ │ │ + T: ZeroablePrimitive + Octal,

    1.74.0 · source§

    impl<T> Octal for Saturating<T>
    where │ │ │ │ + T: Octal,

    1.11.0 · source§

    impl<T> Octal for Wrapping<T>
    where │ │ │ │ T: Octal,

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Pointer.html │ │ │ │ @@ -1,11 +1,11 @@ │ │ │ │ Pointer in alloc::fmt - Rust
    │ │ │ │ -

    Trait alloc::fmt::Pointer

    1.0.0 · source · 
    pub trait Pointer {
│ │ │ │ +    
    Trait alloc::fmt::Pointer
    1.0.0 · source · 
    pub trait Pointer {
│ │ │ │      // Required method
│ │ │ │ -    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │ +    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │  }
    Expand description
    p formatting.
    
│ │ │ │  
    The Pointer trait should format its output as a memory location. This is commonly presented
│ │ │ │  as hexadecimal.
    
│ │ │ │  
    For more information on formatters, see the module-level documentation.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage with &i32:
    
│ │ │ │  
│ │ │ │ @@ -30,16 +30,16 @@
│ │ │ │  let l = Length(42);
│ │ │ │  
│ │ │ │  println!("l is in memory here: {l:p}");
│ │ │ │  
│ │ │ │  let l_ptr = format!("{l:018p}");
│ │ │ │  assert_eq!(l_ptr.len(), 18);
│ │ │ │  assert_eq!(&l_ptr[..2], "0x");
    Run
    │ │ │ │ -

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ -

    Implementors§

    1.4.0 · source§

    impl<F> Pointer for F
    where │ │ │ │ - F: FnPtr,

    1.33.0 · source§

    impl<Ptr> Pointer for Pin<Ptr>
    where │ │ │ │ - Ptr: Pointer,

    source§

    impl<T> Pointer for *const T
    where │ │ │ │ - T: ?Sized,

    source§

    impl<T> Pointer for *mut T
    where │ │ │ │ - T: ?Sized,

    source§

    impl<T> Pointer for &T
    where │ │ │ │ - T: ?Sized,

    source§

    impl<T> Pointer for &mut T
    where │ │ │ │ - T: ?Sized,

    1.25.0 · source§

    impl<T> Pointer for NonNull<T>
    where │ │ │ │ - T: ?Sized,

    1.24.0 · source§

    impl<T> Pointer for AtomicPtr<T>

    source§

    impl<T: ?Sized, A: Allocator> Pointer for Box<T, A>

    source§

    impl<T: ?Sized, A: Allocator> Pointer for Rc<T, A>

    source§

    impl<T: ?Sized, A: Allocator> Pointer for Arc<T, A>

    │ │ │ │ +

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ +

    Implementors§

    1.4.0 · source§

    impl<F> Pointer for F
    where │ │ │ │ + F: FnPtr,

    1.33.0 · source§

    impl<Ptr> Pointer for Pin<Ptr>
    where │ │ │ │ + Ptr: Pointer,

    source§

    impl<T> Pointer for *const T
    where │ │ │ │ + T: ?Sized,

    source§

    impl<T> Pointer for *mut T
    where │ │ │ │ + T: ?Sized,

    source§

    impl<T> Pointer for &T
    where │ │ │ │ + T: ?Sized,

    source§

    impl<T> Pointer for &mut T
    where │ │ │ │ + T: ?Sized,

    1.25.0 · source§

    impl<T> Pointer for NonNull<T>
    where │ │ │ │ + T: ?Sized,

    1.24.0 · source§

    impl<T> Pointer for AtomicPtr<T>

    source§

    impl<T: ?Sized, A: Allocator> Pointer for Box<T, A>

    source§

    impl<T: ?Sized, A: Allocator> Pointer for Rc<T, A>

    source§

    impl<T: ?Sized, A: Allocator> Pointer for Arc<T, A>

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.UpperExp.html │ │ │ │ @@ -1,11 +1,11 @@ │ │ │ │ UpperExp in alloc::fmt - Rust
    │ │ │ │ -

    Trait alloc::fmt::UpperExp

    1.0.0 · source · 
    pub trait UpperExp {
│ │ │ │ +    
    Trait alloc::fmt::UpperExp
    1.0.0 · source · 
    pub trait UpperExp {
│ │ │ │      // Required method
│ │ │ │ -    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │ +    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │  }
    Expand description
    E formatting.
    
│ │ │ │  
    The UpperExp trait should format its output in scientific notation with an upper-case E.
    
│ │ │ │  
    For more information on formatters, see the module-level documentation.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage with f64:
    
│ │ │ │  
│ │ │ │  
    let x = 42.0; // 42.0 is '4.2E1' in scientific notation
│ │ │ │ @@ -31,11 +31,11 @@
│ │ │ │      "l in scientific notation is: 1E2"
│ │ │ │  );
│ │ │ │  
│ │ │ │  assert_eq!(
│ │ │ │      format!("l in scientific notation is: {l:05E}"),
│ │ │ │      "l in scientific notation is: 001E2"
│ │ │ │  );
    Run
    
│ │ │ │ -
    Required Methods§
    source
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter.
    
│ │ │ │ -
    Implementors§
    source§
    impl UpperExp for f32
    source§
    impl UpperExp for f64
    1.42.0 · source§
    impl UpperExp for i8
    1.42.0 · source§
    impl UpperExp for i16
    1.42.0 · source§
    impl UpperExp for i32
    1.42.0 · source§
    impl UpperExp for i64
    1.42.0 · source§
    impl UpperExp for i128
    1.42.0 · source§
    impl UpperExp for isize
    1.42.0 · source§
    impl UpperExp for u8
    1.42.0 · source§
    impl UpperExp for u16
    1.42.0 · source§
    impl UpperExp for u32
    1.42.0 · source§
    impl UpperExp for u64
    1.42.0 · source§
    impl UpperExp for u128
    1.42.0 · source§
    impl UpperExp for usize
    source§
    impl<T> UpperExp for &T
    where
│ │ │ │ -    T: UpperExp + ?Sized,
    source§
    impl<T> UpperExp for &mut T
    where
│ │ │ │ -    T: UpperExp + ?Sized,
    
│ │ │ │ +

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ +

    Implementors§

    source§

    impl UpperExp for f32

    source§

    impl UpperExp for f64

    1.42.0 · source§

    impl UpperExp for i8

    1.42.0 · source§

    impl UpperExp for i16

    1.42.0 · source§

    impl UpperExp for i32

    1.42.0 · source§

    impl UpperExp for i64

    1.42.0 · source§

    impl UpperExp for i128

    1.42.0 · source§

    impl UpperExp for isize

    1.42.0 · source§

    impl UpperExp for u8

    1.42.0 · source§

    impl UpperExp for u16

    1.42.0 · source§

    impl UpperExp for u32

    1.42.0 · source§

    impl UpperExp for u64

    1.42.0 · source§

    impl UpperExp for u128

    1.42.0 · source§

    impl UpperExp for usize

    source§

    impl<T> UpperExp for &T
    where │ │ │ │ + T: UpperExp + ?Sized,

    source§

    impl<T> UpperExp for &mut T
    where │ │ │ │ + T: UpperExp + ?Sized,

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.UpperHex.html │ │ │ │ @@ -1,11 +1,11 @@ │ │ │ │ UpperHex in alloc::fmt - Rust
    │ │ │ │ -

    Trait alloc::fmt::UpperHex

    1.0.0 · source · 
    pub trait UpperHex {
│ │ │ │ +    
    Trait alloc::fmt::UpperHex
    1.0.0 · source · 
    pub trait UpperHex {
│ │ │ │      // Required method
│ │ │ │ -    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │ +    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
│ │ │ │  }
    Expand description
    X formatting.
    
│ │ │ │  
    The UpperHex trait should format its output as a number in hexadecimal, with A through F
│ │ │ │  in upper case.
    
│ │ │ │  
    For primitive signed integers (i8 to i128, and isize),
│ │ │ │  negative values are formatted as the two’s complement representation.
    
│ │ │ │  
    The alternate flag, #, adds a 0x in front of the output.
    
│ │ │ │  
    For more information on formatters, see the module-level documentation.
    
│ │ │ │ @@ -33,14 +33,14 @@
│ │ │ │  }
│ │ │ │  
│ │ │ │  let l = Length(i32::MAX);
│ │ │ │  
│ │ │ │  assert_eq!(format!("l as hex is: {l:X}"), "l as hex is: 7FFFFFFF");
│ │ │ │  
│ │ │ │  assert_eq!(format!("l as hex is: {l:#010X}"), "l as hex is: 0x7FFFFFFF");
    Run
    │ │ │ │ -

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ -

    Implementors§

    source§

    impl UpperHex for i8

    source§

    impl UpperHex for i16

    source§

    impl UpperHex for i32

    source§

    impl UpperHex for i64

    source§

    impl UpperHex for i128

    source§

    impl UpperHex for isize

    source§

    impl UpperHex for u8

    source§

    impl UpperHex for u16

    source§

    impl UpperHex for u32

    source§

    impl UpperHex for u64

    source§

    impl UpperHex for u128

    source§

    impl UpperHex for usize

    source§

    impl<T> UpperHex for &T
    where │ │ │ │ - T: UpperHex + ?Sized,

    source§

    impl<T> UpperHex for &mut T
    where │ │ │ │ - T: UpperHex + ?Sized,

    1.28.0 · source§

    impl<T> UpperHex for NonZero<T>
    where │ │ │ │ - T: ZeroablePrimitive + UpperHex,

    1.74.0 · source§

    impl<T> UpperHex for Saturating<T>
    where │ │ │ │ - T: UpperHex,

    1.11.0 · source§

    impl<T> UpperHex for Wrapping<T>
    where │ │ │ │ +

    Required Methods§

    source

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter.

    │ │ │ │ +

    Implementors§

    source§

    impl UpperHex for i8

    source§

    impl UpperHex for i16

    source§

    impl UpperHex for i32

    source§

    impl UpperHex for i64

    source§

    impl UpperHex for i128

    source§

    impl UpperHex for isize

    source§

    impl UpperHex for u8

    source§

    impl UpperHex for u16

    source§

    impl UpperHex for u32

    source§

    impl UpperHex for u64

    source§

    impl UpperHex for u128

    source§

    impl UpperHex for usize

    source§

    impl<T> UpperHex for &T
    where │ │ │ │ + T: UpperHex + ?Sized,

    source§

    impl<T> UpperHex for &mut T
    where │ │ │ │ + T: UpperHex + ?Sized,

    1.28.0 · source§

    impl<T> UpperHex for NonZero<T>
    where │ │ │ │ + T: ZeroablePrimitive + UpperHex,

    1.74.0 · source§

    impl<T> UpperHex for Saturating<T>
    where │ │ │ │ + T: UpperHex,

    1.11.0 · source§

    impl<T> UpperHex for Wrapping<T>
    where │ │ │ │ T: UpperHex,

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/trait.Write.html │ │ │ │ @@ -1,20 +1,20 @@ │ │ │ │ Write in alloc::fmt - Rust
    │ │ │ │ -

    Trait alloc::fmt::Write

    1.0.0 · source · 
    pub trait Write {
│ │ │ │ +    
    Trait alloc::fmt::Write
    1.0.0 · source · 
    pub trait Write {
│ │ │ │      // Required method
│ │ │ │ -    fn write_str(&mut self, s: &str) -> Result<(), Error>;
│ │ │ │ +    fn write_str(&mut self, s: &str) -> Result<(), Error>;
│ │ │ │  
│ │ │ │      // Provided methods
│ │ │ │ -    fn write_char(&mut self, c: char) -> Result<(), Error> { ... }
│ │ │ │ -    fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error> { ... }
│ │ │ │ +    fn write_char(&mut self, c: char) -> Result<(), Error> { ... }
│ │ │ │ +    fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error> { ... }
│ │ │ │  }
    Expand description
    A trait for writing or formatting into Unicode-accepting buffers or streams.
    
│ │ │ │  
    This trait only accepts UTF-8–encoded data and is not flushable. If you only
│ │ │ │  want to accept Unicode and you don’t need flushing, you should implement this trait;
│ │ │ │  otherwise you should implement std::io::Write.
    
│ │ │ │ -
    Required Methods§
    source
    fn write_str(&mut self, s: &str) -> Result<(), Error>
    Writes a string slice into this writer, returning whether the write
│ │ │ │ +
    Required Methods§
    source
    fn write_str(&mut self, s: &str) -> Result<(), Error>
    Writes a string slice into this writer, returning whether the write
│ │ │ │  succeeded.
    
│ │ │ │  
    This method can only succeed if the entire string slice was successfully
│ │ │ │  written, and this method will not return until all data has been
│ │ │ │  written or an error occurs.
    
│ │ │ │  
    §Errors
    
│ │ │ │  
    This function will return an instance of std::fmt::Error on error.
    
│ │ │ │  
    The purpose of that error is to abort the formatting operation when the underlying
│ │ │ │ @@ -26,16 +26,16 @@
│ │ │ │  fn writer<W: Write>(f: &mut W, s: &str) -> Result<(), Error> {
│ │ │ │      f.write_str(s)
│ │ │ │  }
│ │ │ │  
│ │ │ │  let mut buf = String::new();
│ │ │ │  writer(&mut buf, "hola").unwrap();
│ │ │ │  assert_eq!(&buf, "hola");
    Run
    │ │ │ │ -

    Provided Methods§

    1.1.0 · source

    fn write_char(&mut self, c: char) -> Result<(), Error>

    Writes a char into this writer, returning whether the write succeeded.

    │ │ │ │ -

    A single char may be encoded as more than one byte. │ │ │ │ +

    Provided Methods§

    1.1.0 · source

    fn write_char(&mut self, c: char) -> Result<(), Error>

    Writes a char into this writer, returning whether the write succeeded.

    │ │ │ │ +

    A single char may be encoded as more than one byte. │ │ │ │ This method can only succeed if the entire byte sequence was successfully │ │ │ │ written, and this method will not return until all data has been │ │ │ │ written or an error occurs.

    │ │ │ │
    §Errors
    │ │ │ │

    This function will return an instance of Error on error.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt::{Error, Write};
│ │ │ │ @@ -44,25 +44,25 @@
│ │ │ │      f.write_char(c)
│ │ │ │  }
│ │ │ │  
│ │ │ │  let mut buf = String::new();
│ │ │ │  writer(&mut buf, 'a').unwrap();
│ │ │ │  writer(&mut buf, 'b').unwrap();
│ │ │ │  assert_eq!(&buf, "ab");
    Run
    │ │ │ │ -
    source

    fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

    Glue for usage of the write! macro with implementors of this trait.

    │ │ │ │ +
    source

    fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

    Glue for usage of the write! macro with implementors of this trait.

    │ │ │ │

    This method should generally not be invoked manually, but rather through │ │ │ │ -the write! macro itself.

    │ │ │ │ +the write! macro itself.

    │ │ │ │
    §Errors
    │ │ │ │

    This function will return an instance of Error on error. Please see │ │ │ │ write_str for details.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::fmt::{Error, Write};
│ │ │ │  
│ │ │ │  fn writer<W: Write>(f: &mut W, s: &str) -> Result<(), Error> {
│ │ │ │      f.write_fmt(format_args!("{s}"))
│ │ │ │  }
│ │ │ │  
│ │ │ │  let mut buf = String::new();
│ │ │ │  writer(&mut buf, "world").unwrap();
│ │ │ │  assert_eq!(&buf, "world");
    Run
    │ │ │ │ -

    Implementors§

    source§

    impl Write for String

    1.2.0 · source§

    impl Write for Formatter<'_>

    1.4.0 · source§

    impl<W> Write for &mut W
    where │ │ │ │ - W: Write + ?Sized,

    │ │ │ │ +

    Implementors§

    source§

    impl Write for String

    1.2.0 · source§

    impl Write for Formatter<'_>

    1.4.0 · source§

    impl<W> Write for &mut W
    where │ │ │ │ + W: Write + ?Sized,

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/fmt/type.Result.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ Result in alloc::fmt - Rust
    │ │ │ │ -

    Type Alias alloc::fmt::Result

    1.0.0 · source · 
    pub type Result = Result<(), Error>;
    Expand description

    The type returned by formatter methods.

    │ │ │ │ +

    Type Alias alloc::fmt::Result

    1.0.0 · source · 
    pub type Result = Result<(), Error>;
    Expand description

    The type returned by formatter methods.

    │ │ │ │

    §Examples

    │ │ │ │ 
    use std::fmt;
│ │ │ │  
│ │ │ │  #[derive(Debug)]
│ │ │ │  struct Triangle {
│ │ │ │      a: f32,
│ │ │ │      b: f32,
│ │ │ │ @@ -16,12 +16,12 @@
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  let pythagorean_triple = Triangle { a: 3.0, b: 4.0, c: 5.0 };
│ │ │ │  
│ │ │ │  assert_eq!(format!("{pythagorean_triple}"), "(3, 4, 5)");
    Run
    │ │ │ │

    Aliased Type§

    enum Result {
│ │ │ │ -    Ok(()),
│ │ │ │ +    Ok(()),
│ │ │ │      Err(Error),
│ │ │ │ -}

    Variants§

    §

    Ok(())

    Contains the success value

    │ │ │ │ +}

    Variants§

    §

    Ok(())

    Contains the success value

    │ │ │ │
    §

    Err(Error)

    Contains the error value

    │ │ │ │
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/index.html │ │ │ │ @@ -15,16 +15,16 @@ │ │ │ │ is the same as that of a pointer. Tree-like data structures are often built │ │ │ │ with boxes because each node often has only one owner, the parent.

    │ │ │ │

    §Reference counted pointers

    │ │ │ │

    The Rc type is a non-threadsafe reference-counted pointer type intended │ │ │ │ for sharing memory within a thread. An Rc pointer wraps a type, T, and │ │ │ │ only allows access to &T, a shared reference.

    │ │ │ │

    This type is useful when inherited mutability (such as using Box) is too │ │ │ │ -constraining for an application, and is often paired with the Cell or │ │ │ │ -RefCell types in order to allow mutation.

    │ │ │ │ +constraining for an application, and is often paired with the Cell or │ │ │ │ +RefCell types in order to allow mutation.

    │ │ │ │

    §Atomically reference counted pointers

    │ │ │ │

    The Arc type is the threadsafe equivalent of the Rc type. It │ │ │ │ provides all the same functionality of Rc, except it requires that the │ │ │ │ contained type T is shareable. Additionally, Arc<T> is itself │ │ │ │ sendable while Rc<T> is not.

    │ │ │ │

    This type allows for shared access to the contained data, and is often │ │ │ │ paired with synchronization primitives such as mutexes to allow mutation of │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/macro.format.html │ │ │ │ @@ -6,19 +6,19 @@ │ │ │ │ literal. The power of the formatting string is in the {}s contained. │ │ │ │ Additional parameters passed to format! replace the {}s within the │ │ │ │ formatting string in the order given unless named or positional parameters │ │ │ │ are used.

    │ │ │ │

    See the formatting syntax documentation in std::fmt │ │ │ │ for details.

    │ │ │ │

    A common use for format! is concatenation and interpolation of strings. │ │ │ │ -The same convention is used with print! and write! macros, │ │ │ │ -depending on the intended destination of the string; all these macros internally use format_args!.

    │ │ │ │ +The same convention is used with print! and write! macros, │ │ │ │ +depending on the intended destination of the string; all these macros internally use format_args!.

    │ │ │ │

    To convert a single value to a string, use the to_string method. This │ │ │ │ will use the Display formatting trait.

    │ │ │ │ -

    To concatenate literals into a &'static str, use the concat! macro.

    │ │ │ │ +

    To concatenate literals into a &'static str, use the concat! macro.

    │ │ │ │

    §Panics

    │ │ │ │

    format! panics if a formatting trait implementation returns an error. │ │ │ │ This indicates an incorrect implementation │ │ │ │ since fmt::Write for String never returns an error itself.

    │ │ │ │

    §Examples

    │ │ │ │ 
    format!("test");                             // => "test"
│ │ │ │  format!("hello {}", "world!");               // => "hello world!"
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/macro.vec.html
│ │ │ │ @@ -17,15 +17,15 @@
│ │ │ │  
      
│ │ │ │  
    • Create a Vec from a given element and size:
      • 
│ │ │ │  
    
│ │ │ │  
│ │ │ │  
    let v = vec![1; 3];
│ │ │ │  assert_eq!(v, [1, 1, 1]);
    Run
    
│ │ │ │  
    Note that unlike array expressions this syntax supports all elements
│ │ │ │ -which implement Clone and the number of elements doesn’t have to be
│ │ │ │ +which implement Clone and the number of elements doesn’t have to be
│ │ │ │  a constant.
    
│ │ │ │  
    This will use clone to duplicate an expression, so one should be careful
│ │ │ │  using this with types having a nonstandard Clone implementation. For
│ │ │ │  example, vec![Rc::new(1); 5] will create a vector of five references
│ │ │ │  to the same boxed integer value, not five references pointing to independently
│ │ │ │  boxed integers.
    
│ │ │ │  
    Also, note that vec![expr; 0] is allowed, and produces an empty vector.
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/rc/index.html
│ │ │ │ @@ -1,37 +1,37 @@
│ │ │ │  alloc::rc - Rust
    
│ │ │ │      
    Module alloc::rc
    1.0.0 · source · 
    Expand description
    Single-threaded reference-counting pointers. ‘Rc’ stands for ‘Reference
│ │ │ │  Counted’.
    
│ │ │ │  
    The type Rc<T> provides shared ownership of a value of type T,
│ │ │ │ -allocated in the heap. Invoking clone on Rc produces a new
│ │ │ │ +allocated in the heap. Invoking clone on Rc produces a new
│ │ │ │  pointer to the same allocation in the heap. When the last Rc pointer to a
│ │ │ │  given allocation is destroyed, the value stored in that allocation (often
│ │ │ │  referred to as “inner value”) is also dropped.
    
│ │ │ │  
    Shared references in Rust disallow mutation by default, and Rc
│ │ │ │  is no exception: you cannot generally obtain a mutable reference to
│ │ │ │ -something inside an Rc. If you need mutability, put a Cell
│ │ │ │ -or RefCell inside the Rc; see an example of mutability
│ │ │ │ +something inside an Rc. If you need mutability, put a Cell
│ │ │ │ +or RefCell inside the Rc; see an example of mutability
│ │ │ │  inside an Rc.
    
│ │ │ │  
    Rc uses non-atomic reference counting. This means that overhead is very
│ │ │ │  low, but an Rc cannot be sent between threads, and consequently Rc
│ │ │ │ -does not implement Send. As a result, the Rust compiler
│ │ │ │ +does not implement Send. As a result, the Rust compiler
│ │ │ │  will check at compile time that you are not sending Rcs between
│ │ │ │  threads. If you need multi-threaded, atomic reference counting, use
│ │ │ │  sync::Arc.
    
│ │ │ │  
    The downgrade method can be used to create a non-owning
│ │ │ │  Weak pointer. A Weak pointer can be upgraded
│ │ │ │ -to an Rc, but this will return None if the value stored in the allocation has
│ │ │ │ +to an Rc, but this will return None if the value stored in the allocation has
│ │ │ │  already been dropped. In other words, Weak pointers do not keep the value
│ │ │ │  inside the allocation alive; however, they do keep the allocation
│ │ │ │  (the backing store for the inner value) alive.
    
│ │ │ │  
    A cycle between Rc pointers will never be deallocated. For this reason,
│ │ │ │  Weak is used to break cycles. For example, a tree could have strong
│ │ │ │  Rc pointers from parent nodes to children, and Weak pointers from
│ │ │ │  children back to their parents.
    
│ │ │ │ -
    Rc<T> automatically dereferences to T (via the Deref trait),
│ │ │ │ +
    Rc<T> automatically dereferences to T (via the Deref trait),
│ │ │ │  so you can call T’s methods on a value of type Rc<T>. To avoid name
│ │ │ │  clashes with T’s methods, the methods of Rc<T> itself are associated
│ │ │ │  functions, called using fully qualified syntax:
    
│ │ │ │  
│ │ │ │  
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let my_rc = Rc::new(());
│ │ │ │ @@ -126,17 +126,17 @@
│ │ │ │  a memory leak. In order to get around this, we can use Weak
│ │ │ │  pointers.
    
│ │ │ │  
    Rust actually makes it somewhat difficult to produce this loop in the first
│ │ │ │  place. In order to end up with two values that point at each other, one of
│ │ │ │  them needs to be mutable. This is difficult because Rc enforces
│ │ │ │  memory safety by only giving out shared references to the value it wraps,
│ │ │ │  and these don’t allow direct mutation. We need to wrap the part of the
│ │ │ │ -value we wish to mutate in a RefCell, which provides interior
│ │ │ │ +value we wish to mutate in a RefCell, which provides interior
│ │ │ │  mutability: a method to achieve mutability through a shared reference.
│ │ │ │ -RefCell enforces Rust’s borrowing rules at runtime.
    
│ │ │ │ +RefCell enforces Rust’s borrowing rules at runtime.
    
│ │ │ │  
│ │ │ │  
    use std::rc::Rc;
│ │ │ │  use std::rc::Weak;
│ │ │ │  use std::cell::RefCell;
│ │ │ │  
│ │ │ │  struct Owner {
│ │ │ │      name: String,
│ │ │ │ @@ -203,8 +203,8 @@
│ │ │ │      // are destroyed. There are now no strong (`Rc`) pointers to the
│ │ │ │      // gadgets, so they are destroyed. This zeroes the reference count on
│ │ │ │      // Gadget Man, so he gets destroyed as well.
│ │ │ │  }
    Run
    
│ │ │ │  
    Structs§
    • Rc
      A single-threaded reference-counting pointer. ‘Rc’ stands for ‘Reference
│ │ │ │  Counted’.
    • Weak
      Weak is a version of Rc that holds a non-owning reference to the
│ │ │ │  managed allocation. The allocation is accessed by calling upgrade on the Weak
│ │ │ │ -pointer, which returns an Option<Rc<T>>.
    • UniqueRcExperimental
      A uniquely owned Rc
    
│ │ │ │ +pointer, which returns an Option<Rc<T>>.
  • UniqueRcExperimental
    A uniquely owned Rc
    • │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/rc/struct.Rc.html │ │ │ │ @@ -1,21 +1,21 @@ │ │ │ │ Rc in alloc::rc - Rust
    │ │ │ │ -

    Struct alloc::rc::Rc

    1.0.0 · source · 
    pub struct Rc<T: ?Sized, A: Allocator = Global> { /* private fields */ }
    Expand description

    A single-threaded reference-counting pointer. ‘Rc’ stands for ‘Reference │ │ │ │ +

    Struct alloc::rc::Rc

    1.0.0 · source · 
    pub struct Rc<T: ?Sized, A: Allocator = Global> { /* private fields */ }
    Expand description

    A single-threaded reference-counting pointer. ‘Rc’ stands for ‘Reference │ │ │ │ Counted’.

    │ │ │ │

    See the module-level documentation for more details.

    │ │ │ │

    The inherent methods of Rc are all associated functions, which means │ │ │ │ that you have to call them as e.g., Rc::get_mut(&mut value) instead of │ │ │ │ value.get_mut(). This avoids conflicts with methods of the inner type T.

    │ │ │ │

    Implementations§

    source§

    impl<T> Rc<T>

    source

    pub fn new(value: T) -> Rc<T>

    Constructs a new Rc<T>.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
    Run
    │ │ │ │
    1.60.0 · source

    pub fn new_cyclic<F>(data_fn: F) -> Rc<T>
    where │ │ │ │ - F: FnOnce(&Weak<T>) -> T,

    Constructs a new Rc<T> while giving you a Weak<T> to the allocation, │ │ │ │ + F: FnOnce(&Weak<T>) -> T,

    Constructs a new Rc<T> while giving you a Weak<T> to the allocation, │ │ │ │ to allow you to construct a T which holds a weak pointer to itself.

    │ │ │ │

    Generally, a structure circularly referencing itself, either directly or │ │ │ │ indirectly, should not hold a strong reference to itself to prevent a memory leak. │ │ │ │ Using this function, you get access to the weak pointer during the │ │ │ │ initialization of T, before the Rc<T> is created, such that you can │ │ │ │ clone and store it inside the T.

    │ │ │ │

    new_cyclic first allocates the managed allocation for the Rc<T>, │ │ │ │ @@ -47,90 +47,90 @@ │ │ │ │ } │ │ │ │ │ │ │ │ /// Return a reference counted pointer to Self. │ │ │ │ fn me(&self) -> Rc<Self> { │ │ │ │ self.me.upgrade().unwrap() │ │ │ │ } │ │ │ │ }Run

    │ │ │ │ -
    source

    pub fn new_uninit() -> Rc<MaybeUninit<T>>

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Constructs a new Rc with uninitialized contents.

    │ │ │ │ +
    source

    pub fn new_uninit() -> Rc<MaybeUninit<T>>

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Constructs a new Rc with uninitialized contents.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  
│ │ │ │  let mut five = Rc::<u32>::new_uninit();
│ │ │ │  
│ │ │ │  // Deferred initialization:
│ │ │ │  Rc::get_mut(&mut five).unwrap().write(5);
│ │ │ │  
│ │ │ │  let five = unsafe { five.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5)
    Run
    │ │ │ │ -
    source

    pub fn new_zeroed() -> Rc<MaybeUninit<T>>

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Constructs a new Rc with uninitialized contents, with the memory │ │ │ │ +

    source

    pub fn new_zeroed() -> Rc<MaybeUninit<T>>

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Constructs a new Rc with uninitialized contents, with the memory │ │ │ │ being filled with 0 bytes.

    │ │ │ │ -

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ +

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ incorrect usage of this method.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(new_uninit)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  
│ │ │ │  let zero = Rc::<u32>::new_zeroed();
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*zero, 0)
    Run
    │ │ │ │ -
    source

    pub fn try_new(value: T) -> Result<Rc<T>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc<T>, returning an error if the allocation fails

    │ │ │ │ +
    source

    pub fn try_new(value: T) -> Result<Rc<T>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc<T>, returning an error if the allocation fails

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(allocator_api)]
│ │ │ │  use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::try_new(5);
    Run
    │ │ │ │ -
    source

    pub fn try_new_uninit() -> Result<Rc<MaybeUninit<T>>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents, returning an error if the allocation fails

    │ │ │ │ +
    source

    pub fn try_new_uninit() -> Result<Rc<MaybeUninit<T>>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents, returning an error if the allocation fails

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(allocator_api, new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  
│ │ │ │  let mut five = Rc::<u32>::try_new_uninit()?;
│ │ │ │  
│ │ │ │  // Deferred initialization:
│ │ │ │  Rc::get_mut(&mut five).unwrap().write(5);
│ │ │ │  
│ │ │ │  let five = unsafe { five.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5);
    Run
    │ │ │ │ -
    source

    pub fn try_new_zeroed() -> Result<Rc<MaybeUninit<T>>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents, with the memory │ │ │ │ +

    source

    pub fn try_new_zeroed() -> Result<Rc<MaybeUninit<T>>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents, with the memory │ │ │ │ being filled with 0 bytes, returning an error if the allocation fails

    │ │ │ │ -

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ +

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ incorrect usage of this method.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  
│ │ │ │  let zero = Rc::<u32>::try_new_zeroed()?;
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*zero, 0);
    Run
    │ │ │ │ -
    1.33.0 · source

    pub fn pin(value: T) -> Pin<Rc<T>>

    Constructs a new Pin<Rc<T>>. If T does not implement Unpin, then │ │ │ │ +

    1.33.0 · source

    pub fn pin(value: T) -> Pin<Rc<T>>

    Constructs a new Pin<Rc<T>>. If T does not implement Unpin, then │ │ │ │ value will be pinned in memory and unable to be moved.

    │ │ │ │ -
    source§

    impl<T, A: Allocator> Rc<T, A>

    source

    pub fn allocator(this: &Self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │ +
    source§

    impl<T, A: Allocator> Rc<T, A>

    source

    pub fn allocator(this: &Self) -> &A

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Returns a reference to the underlying allocator.

    │ │ │ │

    Note: this is an associated function, which means that you have │ │ │ │ to call it as Rc::allocator(&r) instead of r.allocator(). This │ │ │ │ is so that there is no conflict with a method on the inner type.

    │ │ │ │
    source

    pub fn new_in(value: T, alloc: A) -> Rc<T, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc in the provided allocator.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(allocator_api)]
│ │ │ │  use std::rc::Rc;
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let five = Rc::new_in(5, System);
    Run
    │ │ │ │ -
    source

    pub fn new_uninit_in(alloc: A) -> Rc<MaybeUninit<T>, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents in the provided allocator.

    │ │ │ │ +
    source

    pub fn new_uninit_in(alloc: A) -> Rc<MaybeUninit<T>, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents in the provided allocator.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  use std::alloc::System;
│ │ │ │ @@ -141,38 +141,38 @@
│ │ │ │      // Deferred initialization:
│ │ │ │      Rc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);
│ │ │ │  
│ │ │ │      five.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5)
    Run
    │ │ │ │ -
    source

    pub fn new_zeroed_in(alloc: A) -> Rc<MaybeUninit<T>, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents, with the memory │ │ │ │ +

    source

    pub fn new_zeroed_in(alloc: A) -> Rc<MaybeUninit<T>, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents, with the memory │ │ │ │ being filled with 0 bytes, in the provided allocator.

    │ │ │ │ -

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ +

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ incorrect usage of this method.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(new_uninit)]
│ │ │ │  #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let zero = Rc::<u32, _>::new_zeroed_in(System);
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*zero, 0)
    Run
    │ │ │ │ -
    source

    pub fn try_new_in(value: T, alloc: A) -> Result<Self, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc<T> in the provided allocator, returning an error if the allocation │ │ │ │ +

    source

    pub fn try_new_in(value: T, alloc: A) -> Result<Self, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc<T> in the provided allocator, returning an error if the allocation │ │ │ │ fails

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(allocator_api)]
│ │ │ │  use std::rc::Rc;
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let five = Rc::try_new_in(5, System);
    Run
    │ │ │ │ -
    source

    pub fn try_new_uninit_in(alloc: A) -> Result<Rc<MaybeUninit<T>, A>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents, in the provided allocator, returning an │ │ │ │ +

    source

    pub fn try_new_uninit_in(alloc: A) -> Result<Rc<MaybeUninit<T>, A>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents, in the provided allocator, returning an │ │ │ │ error if the allocation fails

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(allocator_api, new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  use std::alloc::System;
│ │ │ │ @@ -183,67 +183,67 @@
│ │ │ │      // Deferred initialization:
│ │ │ │      Rc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);
│ │ │ │  
│ │ │ │      five.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5);
    Run
    │ │ │ │ -
    source

    pub fn try_new_zeroed_in(alloc: A) -> Result<Rc<MaybeUninit<T>, A>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents, with the memory │ │ │ │ +

    source

    pub fn try_new_zeroed_in(alloc: A) -> Result<Rc<MaybeUninit<T>, A>, AllocError>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Rc with uninitialized contents, with the memory │ │ │ │ being filled with 0 bytes, in the provided allocator, returning an error if the allocation │ │ │ │ fails

    │ │ │ │ -

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ +

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ incorrect usage of this method.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(allocator_api, new_uninit)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let zero = Rc::<u32, _>::try_new_zeroed_in(System)?;
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*zero, 0);
    Run
    │ │ │ │ -
    source

    pub fn pin_in(value: T, alloc: A) -> Pin<Self>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Pin<Rc<T>> in the provided allocator. If T does not implement Unpin, then │ │ │ │ +

    source

    pub fn pin_in(value: T, alloc: A) -> Pin<Self>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Pin<Rc<T>> in the provided allocator. If T does not implement Unpin, then │ │ │ │ value will be pinned in memory and unable to be moved.

    │ │ │ │ -
    1.4.0 · source

    pub fn try_unwrap(this: Self) -> Result<T, Self>

    Returns the inner value, if the Rc has exactly one strong reference.

    │ │ │ │ -

    Otherwise, an Err is returned with the same Rc that was │ │ │ │ +

    1.4.0 · source

    pub fn try_unwrap(this: Self) -> Result<T, Self>

    Returns the inner value, if the Rc has exactly one strong reference.

    │ │ │ │ +

    Otherwise, an Err is returned with the same Rc that was │ │ │ │ passed in.

    │ │ │ │

    This will succeed even if there are outstanding weak references.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let x = Rc::new(3);
│ │ │ │  assert_eq!(Rc::try_unwrap(x), Ok(3));
│ │ │ │  
│ │ │ │  let x = Rc::new(4);
│ │ │ │  let _y = Rc::clone(&x);
│ │ │ │  assert_eq!(*Rc::try_unwrap(x).unwrap_err(), 4);
    Run
    │ │ │ │ -
    1.70.0 · source

    pub fn into_inner(this: Self) -> Option<T>

    Returns the inner value, if the Rc has exactly one strong reference.

    │ │ │ │ -

    Otherwise, None is returned and the Rc is dropped.

    │ │ │ │ +
    1.70.0 · source

    pub fn into_inner(this: Self) -> Option<T>

    Returns the inner value, if the Rc has exactly one strong reference.

    │ │ │ │ +

    Otherwise, None is returned and the Rc is dropped.

    │ │ │ │

    This will succeed even if there are outstanding weak references.

    │ │ │ │

    If Rc::into_inner is called on every clone of this Rc, │ │ │ │ it is guaranteed that exactly one of the calls returns the inner value. │ │ │ │ This means in particular that the inner value is not dropped.

    │ │ │ │

    Rc::try_unwrap is conceptually similar to Rc::into_inner. │ │ │ │ And while they are meant for different use-cases, Rc::into_inner(this) │ │ │ │ -is in fact equivalent to Rc::try_unwrap(this).ok(). │ │ │ │ +is in fact equivalent to Rc::try_unwrap(this).ok(). │ │ │ │ (Note that the same kind of equivalence does not hold true for │ │ │ │ Arc, due to race conditions that do not apply to Rc!)

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let x = Rc::new(3);
│ │ │ │  assert_eq!(Rc::into_inner(x), Some(3));
│ │ │ │  
│ │ │ │  let x = Rc::new(4);
│ │ │ │  let y = Rc::clone(&x);
│ │ │ │  
│ │ │ │  assert_eq!(Rc::into_inner(y), None);
│ │ │ │  assert_eq!(Rc::into_inner(x), Some(4));
    Run
    │ │ │ │ -
    source§

    impl<T> Rc<[T]>

    source

    pub fn new_uninit_slice(len: usize) -> Rc<[MaybeUninit<T>]>

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Constructs a new reference-counted slice with uninitialized contents.

    │ │ │ │ +
    source§

    impl<T> Rc<[T]>

    source

    pub fn new_uninit_slice(len: usize) -> Rc<[MaybeUninit<T>]>

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Constructs a new reference-counted slice with uninitialized contents.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  
│ │ │ │  let mut values = Rc::<[u32]>::new_uninit_slice(3);
│ │ │ │ @@ -253,28 +253,28 @@
│ │ │ │  data[0].write(1);
│ │ │ │  data[1].write(2);
│ │ │ │  data[2].write(3);
│ │ │ │  
│ │ │ │  let values = unsafe { values.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [1, 2, 3])
    Run
    │ │ │ │ -
    source

    pub fn new_zeroed_slice(len: usize) -> Rc<[MaybeUninit<T>]>

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Constructs a new reference-counted slice with uninitialized contents, with the memory being │ │ │ │ +

    source

    pub fn new_zeroed_slice(len: usize) -> Rc<[MaybeUninit<T>]>

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Constructs a new reference-counted slice with uninitialized contents, with the memory being │ │ │ │ filled with 0 bytes.

    │ │ │ │ -

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ +

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ incorrect usage of this method.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(new_uninit)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  
│ │ │ │  let values = Rc::<[u32]>::new_zeroed_slice(3);
│ │ │ │  let values = unsafe { values.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [0, 0, 0])
    Run
    │ │ │ │ -
    source§

    impl<T, A: Allocator> Rc<[T], A>

    source

    pub fn new_uninit_slice_in(len: usize, alloc: A) -> Rc<[MaybeUninit<T>], A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new reference-counted slice with uninitialized contents.

    │ │ │ │ +
    source§

    impl<T, A: Allocator> Rc<[T], A>

    source

    pub fn new_uninit_slice_in(len: usize, alloc: A) -> Rc<[MaybeUninit<T>], A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new reference-counted slice with uninitialized contents.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  use std::alloc::System;
│ │ │ │ @@ -287,33 +287,33 @@
│ │ │ │      Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);
│ │ │ │      Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);
│ │ │ │  
│ │ │ │      values.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [1, 2, 3])
    Run
    │ │ │ │ -
    source

    pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Rc<[MaybeUninit<T>], A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new reference-counted slice with uninitialized contents, with the memory being │ │ │ │ +

    source

    pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Rc<[MaybeUninit<T>], A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new reference-counted slice with uninitialized contents, with the memory being │ │ │ │ filled with 0 bytes.

    │ │ │ │ -

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ +

    See MaybeUninit::zeroed for examples of correct and │ │ │ │ incorrect usage of this method.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(new_uninit)]
│ │ │ │  #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::rc::Rc;
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let values = Rc::<[u32], _>::new_zeroed_slice_in(3, System);
│ │ │ │  let values = unsafe { values.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [0, 0, 0])
    Run
    │ │ │ │ -
    source§

    impl<T, A: Allocator> Rc<MaybeUninit<T>, A>

    source

    pub unsafe fn assume_init(self) -> Rc<T, A>
    where │ │ │ │ - A: Clone,

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Converts to Rc<T>.

    │ │ │ │ +
    source§

    impl<T, A: Allocator> Rc<MaybeUninit<T>, A>

    source

    pub unsafe fn assume_init(self) -> Rc<T, A>
    where │ │ │ │ + A: Clone,

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Converts to Rc<T>.

    │ │ │ │
    §Safety
    │ │ │ │ -

    As with MaybeUninit::assume_init, │ │ │ │ +

    As with MaybeUninit::assume_init, │ │ │ │ it is up to the caller to guarantee that the inner value │ │ │ │ really is in an initialized state. │ │ │ │ Calling this when the content is not yet fully initialized │ │ │ │ causes immediate undefined behavior.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │ @@ -324,18 +324,18 @@
│ │ │ │  
│ │ │ │  // Deferred initialization:
│ │ │ │  Rc::get_mut(&mut five).unwrap().write(5);
│ │ │ │  
│ │ │ │  let five = unsafe { five.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5)
    Run
    │ │ │ │ -
    source§

    impl<T, A: Allocator> Rc<[MaybeUninit<T>], A>

    source

    pub unsafe fn assume_init(self) -> Rc<[T], A>
    where │ │ │ │ - A: Clone,

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Converts to Rc<[T]>.

    │ │ │ │ +
    source§

    impl<T, A: Allocator> Rc<[MaybeUninit<T>], A>

    source

    pub unsafe fn assume_init(self) -> Rc<[T], A>
    where │ │ │ │ + A: Clone,

    🔬This is a nightly-only experimental API. (new_uninit #63291)

    Converts to Rc<[T]>.

    │ │ │ │
    §Safety
    │ │ │ │ -

    As with MaybeUninit::assume_init, │ │ │ │ +

    As with MaybeUninit::assume_init, │ │ │ │ it is up to the caller to guarantee that the inner value │ │ │ │ really is in an initialized state. │ │ │ │ Calling this when the content is not yet fully initialized │ │ │ │ causes immediate undefined behavior.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │ @@ -349,28 +349,28 @@
│ │ │ │  data[0].write(1);
│ │ │ │  data[1].write(2);
│ │ │ │  data[2].write(3);
│ │ │ │  
│ │ │ │  let values = unsafe { values.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [1, 2, 3])
    Run
    │ │ │ │ -
    source§

    impl<T: ?Sized> Rc<T>

    1.17.0 · source

    pub unsafe fn from_raw(ptr: *const T) -> Self

    Constructs an Rc<T> from a raw pointer.

    │ │ │ │ +
    source§

    impl<T: ?Sized> Rc<T>

    1.17.0 · source

    pub unsafe fn from_raw(ptr: *const T) -> Self

    Constructs an Rc<T> from a raw pointer.

    │ │ │ │

    The raw pointer must have been previously returned by a call to │ │ │ │ Rc<U>::into_raw with the following requirements:

    │ │ │ │
      │ │ │ │
    • If U is sized, it must have the same size and alignment as T. This │ │ │ │ is trivially true if U is T.
      • │ │ │ │
    • If U is unsized, its data pointer must have the same size and │ │ │ │ alignment as T. This is trivially true if Rc<U> was constructed │ │ │ │ through Rc<T> and then converted to Rc<U> through an unsized │ │ │ │ coercion.
      • │ │ │ │
    │ │ │ │

    Note that if U or U’s data pointer is not T but has the same size │ │ │ │ and alignment, this is basically like transmuting references of │ │ │ │ -different types. See mem::transmute for more information │ │ │ │ +different types. See mem::transmute for more information │ │ │ │ on what restrictions apply in this case.

    │ │ │ │

    The raw pointer must point to a block of memory allocated by the global allocator

    │ │ │ │

    The user of from_raw has to make sure a specific value of T is only │ │ │ │ dropped once.

    │ │ │ │

    This function is unsafe because improper use may lead to memory unsafety, │ │ │ │ even if the returned Rc<T> is never accessed.

    │ │ │ │
    §Examples
    │ │ │ │ @@ -395,15 +395,15 @@ │ │ │ │ let x: Rc<[u32]> = Rc::new([1, 2, 3]); │ │ │ │ let x_ptr: *const [u32] = Rc::into_raw(x); │ │ │ │ │ │ │ │ unsafe { │ │ │ │ let x: Rc<[u32; 3]> = Rc::from_raw(x_ptr.cast::<[u32; 3]>()); │ │ │ │ assert_eq!(&*x, &[1, 2, 3]); │ │ │ │ }    Run
    │ │ │ │ -
    1.53.0 · source

    pub unsafe fn increment_strong_count(ptr: *const T)

    Increments the strong reference count on the Rc<T> associated with the │ │ │ │ +

    1.53.0 · source

    pub unsafe fn increment_strong_count(ptr: *const T)

    Increments the strong reference count on the Rc<T> associated with the │ │ │ │ provided pointer by one.

    │ │ │ │
    §Safety
    │ │ │ │

    The pointer must have been obtained through Rc::into_raw, the │ │ │ │ associated Rc instance must be valid (i.e. the strong count must be at │ │ │ │ least 1) for the duration of this method, and ptr must point to a block of memory │ │ │ │ allocated by the global allocator.

    │ │ │ │
    §Examples
    │ │ │ │ @@ -414,15 +414,15 @@ │ │ │ │ unsafe { │ │ │ │ let ptr = Rc::into_raw(five); │ │ │ │ Rc::increment_strong_count(ptr); │ │ │ │ │ │ │ │ let five = Rc::from_raw(ptr); │ │ │ │ assert_eq!(2, Rc::strong_count(&five)); │ │ │ │ }    Run
    │ │ │ │ -
    1.53.0 · source

    pub unsafe fn decrement_strong_count(ptr: *const T)

    Decrements the strong reference count on the Rc<T> associated with the │ │ │ │ +

    1.53.0 · source

    pub unsafe fn decrement_strong_count(ptr: *const T)

    Decrements the strong reference count on the Rc<T> associated with the │ │ │ │ provided pointer by one.

    │ │ │ │
    §Safety
    │ │ │ │

    The pointer must have been obtained through Rc::into_raw, the │ │ │ │ associated Rc instance must be valid (i.e. the strong count must be at │ │ │ │ least 1) when invoking this method, and ptr must point to a block of memory │ │ │ │ allocated by the global allocator. This method can be used to release the final Rc and │ │ │ │ backing storage, but should not be called after the final Rc has been released.

    │ │ │ │ @@ -436,47 +436,47 @@ │ │ │ │ Rc::increment_strong_count(ptr); │ │ │ │ │ │ │ │ let five = Rc::from_raw(ptr); │ │ │ │ assert_eq!(2, Rc::strong_count(&five)); │ │ │ │ Rc::decrement_strong_count(ptr); │ │ │ │ assert_eq!(1, Rc::strong_count(&five)); │ │ │ │ }Run
    │ │ │ │ -
    source§

    impl<T: ?Sized, A: Allocator> Rc<T, A>

    1.17.0 · source

    pub fn into_raw(this: Self) -> *const T

    Consumes the Rc, returning the wrapped pointer.

    │ │ │ │ +
    source§

    impl<T: ?Sized, A: Allocator> Rc<T, A>

    1.17.0 · source

    pub fn into_raw(this: Self) -> *const T

    Consumes the Rc, returning the wrapped pointer.

    │ │ │ │

    To avoid a memory leak the pointer must be converted back to an Rc using │ │ │ │ Rc::from_raw.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let x = Rc::new("hello".to_owned());
│ │ │ │  let x_ptr = Rc::into_raw(x);
│ │ │ │  assert_eq!(unsafe { &*x_ptr }, "hello");
    Run
    │ │ │ │ -
    1.45.0 · source

    pub fn as_ptr(this: &Self) -> *const T

    Provides a raw pointer to the data.

    │ │ │ │ +
    1.45.0 · source

    pub fn as_ptr(this: &Self) -> *const T

    Provides a raw pointer to the data.

    │ │ │ │

    The counts are not affected in any way and the Rc is not consumed. The pointer is valid │ │ │ │ for as long there are strong counts in the Rc.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let x = Rc::new("hello".to_owned());
│ │ │ │  let y = Rc::clone(&x);
│ │ │ │  let x_ptr = Rc::as_ptr(&x);
│ │ │ │  assert_eq!(x_ptr, Rc::as_ptr(&y));
│ │ │ │  assert_eq!(unsafe { &*x_ptr }, "hello");
    Run
    │ │ │ │ -
    source

    pub unsafe fn from_raw_in(ptr: *const T, alloc: A) -> Self

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs an Rc<T, A> from a raw pointer in the provided allocator.

    │ │ │ │ +
    source

    pub unsafe fn from_raw_in(ptr: *const T, alloc: A) -> Self

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs an Rc<T, A> from a raw pointer in the provided allocator.

    │ │ │ │

    The raw pointer must have been previously returned by a call to Rc<U, A>::into_raw with the following requirements:

    │ │ │ │
      │ │ │ │
    • If U is sized, it must have the same size and alignment as T. This │ │ │ │ is trivially true if U is T.
      • │ │ │ │
    • If U is unsized, its data pointer must have the same size and │ │ │ │ alignment as T. This is trivially true if Rc<U> was constructed │ │ │ │ through Rc<T> and then converted to Rc<U> through an unsized │ │ │ │ coercion.
      • │ │ │ │
    │ │ │ │

    Note that if U or U’s data pointer is not T but has the same size │ │ │ │ and alignment, this is basically like transmuting references of │ │ │ │ -different types. See mem::transmute for more information │ │ │ │ +different types. See mem::transmute for more information │ │ │ │ on what restrictions apply in this case.

    │ │ │ │

    The raw pointer must point to a block of memory allocated by alloc

    │ │ │ │

    The user of from_raw has to make sure a specific value of T is only │ │ │ │ dropped once.

    │ │ │ │

    This function is unsafe because improper use may lead to memory unsafety, │ │ │ │ even if the returned Rc<T> is never accessed.

    │ │ │ │
    §Examples
    │ │ │ │ @@ -507,40 +507,40 @@ │ │ │ │ let x: Rc<[u32], _> = Rc::new_in([1, 2, 3], System); │ │ │ │ let x_ptr: *const [u32] = Rc::into_raw(x); │ │ │ │ │ │ │ │ unsafe { │ │ │ │ let x: Rc<[u32; 3], _> = Rc::from_raw_in(x_ptr.cast::<[u32; 3]>(), System); │ │ │ │ assert_eq!(&*x, &[1, 2, 3]); │ │ │ │ }Run
    │ │ │ │ -
    1.4.0 · source

    pub fn downgrade(this: &Self) -> Weak<T, A>
    where │ │ │ │ - A: Clone,

    Creates a new Weak pointer to this allocation.

    │ │ │ │ +
    1.4.0 · source

    pub fn downgrade(this: &Self) -> Weak<T, A>
    where │ │ │ │ + A: Clone,

    Creates a new Weak pointer to this allocation.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  
│ │ │ │  let weak_five = Rc::downgrade(&five);
    Run
    │ │ │ │ -
    1.15.0 · source

    pub fn weak_count(this: &Self) -> usize

    Gets the number of Weak pointers to this allocation.

    │ │ │ │ +
    1.15.0 · source

    pub fn weak_count(this: &Self) -> usize

    Gets the number of Weak pointers to this allocation.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  let _weak_five = Rc::downgrade(&five);
│ │ │ │  
│ │ │ │  assert_eq!(1, Rc::weak_count(&five));
    Run
    │ │ │ │ -
    1.15.0 · source

    pub fn strong_count(this: &Self) -> usize

    Gets the number of strong (Rc) pointers to this allocation.

    │ │ │ │ +
    1.15.0 · source

    pub fn strong_count(this: &Self) -> usize

    Gets the number of strong (Rc) pointers to this allocation.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  let _also_five = Rc::clone(&five);
│ │ │ │  
│ │ │ │  assert_eq!(2, Rc::strong_count(&five));
    Run
    │ │ │ │ -
    source

    pub unsafe fn increment_strong_count_in(ptr: *const T, alloc: A)
    where │ │ │ │ - A: Clone,

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Increments the strong reference count on the Rc<T> associated with the │ │ │ │ +

    source

    pub unsafe fn increment_strong_count_in(ptr: *const T, alloc: A)
    where │ │ │ │ + A: Clone,

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Increments the strong reference count on the Rc<T> associated with the │ │ │ │ provided pointer by one.

    │ │ │ │
    §Safety
    │ │ │ │

    The pointer must have been obtained through Rc::into_raw, the │ │ │ │ associated Rc instance must be valid (i.e. the strong count must be at │ │ │ │ least 1) for the duration of this method, and ptr must point to a block of memory │ │ │ │ allocated by alloc

    │ │ │ │
    §Examples
    │ │ │ │ @@ -554,15 +554,15 @@ │ │ │ │ unsafe { │ │ │ │ let ptr = Rc::into_raw(five); │ │ │ │ Rc::increment_strong_count_in(ptr, System); │ │ │ │ │ │ │ │ let five = Rc::from_raw_in(ptr, System); │ │ │ │ assert_eq!(2, Rc::strong_count(&five)); │ │ │ │ }Run
    │ │ │ │ -
    source

    pub unsafe fn decrement_strong_count_in(ptr: *const T, alloc: A)

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Decrements the strong reference count on the Rc<T> associated with the │ │ │ │ +

    source

    pub unsafe fn decrement_strong_count_in(ptr: *const T, alloc: A)

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Decrements the strong reference count on the Rc<T> associated with the │ │ │ │ provided pointer by one.

    │ │ │ │
    §Safety
    │ │ │ │

    The pointer must have been obtained through Rc::into_raw, the │ │ │ │ associated Rc instance must be valid (i.e. the strong count must be at │ │ │ │ least 1) when invoking this method, and ptr must point to a block of memory │ │ │ │ allocated by alloc. This method can be used to release the final Rc and backing storage, │ │ │ │ but should not be called after the final Rc has been released.

    │ │ │ │ @@ -579,30 +579,30 @@ │ │ │ │ Rc::increment_strong_count_in(ptr, System); │ │ │ │ │ │ │ │ let five = Rc::from_raw_in(ptr, System); │ │ │ │ assert_eq!(2, Rc::strong_count(&five)); │ │ │ │ Rc::decrement_strong_count_in(ptr, System); │ │ │ │ assert_eq!(1, Rc::strong_count(&five)); │ │ │ │ }Run
    │ │ │ │ -
    1.4.0 · source

    pub fn get_mut(this: &mut Self) -> Option<&mut T>

    Returns a mutable reference into the given Rc, if there are │ │ │ │ +

    1.4.0 · source

    pub fn get_mut(this: &mut Self) -> Option<&mut T>

    Returns a mutable reference into the given Rc, if there are │ │ │ │ no other Rc or Weak pointers to the same allocation.

    │ │ │ │ -

    Returns None otherwise, because it is not safe to │ │ │ │ +

    Returns None otherwise, because it is not safe to │ │ │ │ mutate a shared value.

    │ │ │ │ -

    See also make_mut, which will clone │ │ │ │ +

    See also make_mut, which will clone │ │ │ │ the inner value when there are other Rc pointers.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let mut x = Rc::new(3);
│ │ │ │  *Rc::get_mut(&mut x).unwrap() = 4;
│ │ │ │  assert_eq!(*x, 4);
│ │ │ │  
│ │ │ │  let _y = Rc::clone(&x);
│ │ │ │  assert!(Rc::get_mut(&mut x).is_none());
    Run
    │ │ │ │ -
    source

    pub unsafe fn get_mut_unchecked(this: &mut Self) -> &mut T

    🔬This is a nightly-only experimental API. (get_mut_unchecked #63292)

    Returns a mutable reference into the given Rc, │ │ │ │ +

    source

    pub unsafe fn get_mut_unchecked(this: &mut Self) -> &mut T

    🔬This is a nightly-only experimental API. (get_mut_unchecked #63292)

    Returns a mutable reference into the given Rc, │ │ │ │ without any check.

    │ │ │ │

    See also get_mut, which is safe and does appropriate checks.

    │ │ │ │
    §Safety
    │ │ │ │

    If any other Rc or Weak pointers to the same allocation exist, then │ │ │ │ they must not be dereferenced or have active borrows for the duration │ │ │ │ of the returned borrow, and their inner type must be exactly the same as the │ │ │ │ inner type of this Rc (including lifetimes). This is trivially the case if no │ │ │ │ @@ -643,28 +643,28 @@ │ │ │ │ unsafe { │ │ │ │ // this is Undefined Behavior, because x's inner type │ │ │ │ // is &'long str, not &'short str │ │ │ │ *Rc::get_mut_unchecked(&mut y) = &s; │ │ │ │ } │ │ │ │ } │ │ │ │ println!("{}", &*x); // Use-after-freeRun

    │ │ │ │ -
    1.17.0 · source

    pub fn ptr_eq(this: &Self, other: &Self) -> bool

    Returns true if the two Rcs point to the same allocation in a vein similar to │ │ │ │ -ptr::eq. This function ignores the metadata of dyn Trait pointers.

    │ │ │ │ +
    1.17.0 · source

    pub fn ptr_eq(this: &Self, other: &Self) -> bool

    Returns true if the two Rcs point to the same allocation in a vein similar to │ │ │ │ +ptr::eq. This function ignores the metadata of dyn Trait pointers.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  let same_five = Rc::clone(&five);
│ │ │ │  let other_five = Rc::new(5);
│ │ │ │  
│ │ │ │  assert!(Rc::ptr_eq(&five, &same_five));
│ │ │ │  assert!(!Rc::ptr_eq(&five, &other_five));
    Run
    │ │ │ │ -
    source§

    impl<T: Clone, A: Allocator + Clone> Rc<T, A>

    1.4.0 · source

    pub fn make_mut(this: &mut Self) -> &mut T

    Makes a mutable reference into the given Rc.

    │ │ │ │ +
    source§

    impl<T: Clone, A: Allocator + Clone> Rc<T, A>

    1.4.0 · source

    pub fn make_mut(this: &mut Self) -> &mut T

    Makes a mutable reference into the given Rc.

    │ │ │ │

    If there are other Rc pointers to the same allocation, then make_mut will │ │ │ │ -clone the inner value to a new allocation to ensure unique ownership. This is also │ │ │ │ +clone the inner value to a new allocation to ensure unique ownership. This is also │ │ │ │ referred to as clone-on-write.

    │ │ │ │

    However, if there are no other Rc pointers to this allocation, but some Weak │ │ │ │ pointers, then the Weak pointers will be disassociated and the inner value will not │ │ │ │ be cloned.

    │ │ │ │

    See also get_mut, which will fail rather than cloning the inner value │ │ │ │ or disassociating Weak pointers.

    │ │ │ │
    §Examples
    │ │ │ │ @@ -713,29 +713,29 @@ │ │ │ │ let inner = Rc::unwrap_or_clone(rc); │ │ │ │ // Because there were 2 references, we had to clone the inner value. │ │ │ │ assert!(!ptr::eq(ptr, inner.as_ptr())); │ │ │ │ // `rc2` is the last reference, so when we unwrap it we get back │ │ │ │ // the original `String`. │ │ │ │ let inner = Rc::unwrap_or_clone(rc2); │ │ │ │ assert!(ptr::eq(ptr, inner.as_ptr()));Run
    │ │ │ │ -
    source§

    impl<A: Allocator + Clone> Rc<dyn Any, A>

    1.29.0 · source

    pub fn downcast<T: Any>(self) -> Result<Rc<T, A>, Self>

    Attempt to downcast the Rc<dyn Any> to a concrete type.

    │ │ │ │ +
    source§

    impl<A: Allocator + Clone> Rc<dyn Any, A>

    1.29.0 · source

    pub fn downcast<T: Any>(self) -> Result<Rc<T, A>, Self>

    Attempt to downcast the Rc<dyn Any> to a concrete type.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::any::Any;
│ │ │ │  use std::rc::Rc;
│ │ │ │  
│ │ │ │  fn print_if_string(value: Rc<dyn Any>) {
│ │ │ │      if let Ok(string) = value.downcast::<String>() {
│ │ │ │          println!("String ({}): {}", string.len(), string);
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  let my_string = "Hello World".to_string();
│ │ │ │  print_if_string(Rc::new(my_string));
│ │ │ │  print_if_string(Rc::new(0i8));
    Run
    │ │ │ │ -
    source

    pub unsafe fn downcast_unchecked<T: Any>(self) -> Rc<T, A>

    🔬This is a nightly-only experimental API. (downcast_unchecked #90850)

    Downcasts the Rc<dyn Any> to a concrete type.

    │ │ │ │ +
    source

    pub unsafe fn downcast_unchecked<T: Any>(self) -> Rc<T, A>

    🔬This is a nightly-only experimental API. (downcast_unchecked #90850)

    Downcasts the Rc<dyn Any> to a concrete type.

    │ │ │ │

    For a safe alternative see downcast.

    │ │ │ │
    §Examples
    │ │ │ │ 
    #![feature(downcast_unchecked)]
│ │ │ │  
│ │ │ │  use std::any::Any;
│ │ │ │  use std::rc::Rc;
│ │ │ │  
│ │ │ │ @@ -743,30 +743,30 @@
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      assert_eq!(*x.downcast_unchecked::<usize>(), 1);
│ │ │ │  }
    Run
    │ │ │ │
    §Safety
    │ │ │ │

    The contained value must be of type T. Calling this method │ │ │ │ with the incorrect type is undefined behavior.

    │ │ │ │ -

    Trait Implementations§

    1.5.0 · source§

    impl<T: ?Sized, A: Allocator> AsRef<T> for Rc<T, A>

    source§

    fn as_ref(&self) -> &T

    Converts this type into a shared reference of the (usually inferred) input type.
    source§

    impl<T: ?Sized, A: Allocator> Borrow<T> for Rc<T, A>

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T: ?Sized, A: Allocator + Clone> Clone for Rc<T, A>

    source§

    fn clone(&self) -> Self

    Makes a clone of the Rc pointer.

    │ │ │ │ +

    Trait Implementations§

    1.5.0 · source§

    impl<T: ?Sized, A: Allocator> AsRef<T> for Rc<T, A>

    source§

    fn as_ref(&self) -> &T

    Converts this type into a shared reference of the (usually inferred) input type.
    source§

    impl<T: ?Sized, A: Allocator> Borrow<T> for Rc<T, A>

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T: ?Sized, A: Allocator + Clone> Clone for Rc<T, A>

    source§

    fn clone(&self) -> Self

    Makes a clone of the Rc pointer.

    │ │ │ │

    This creates another pointer to the same allocation, increasing the │ │ │ │ strong reference count.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  
│ │ │ │  let _ = Rc::clone(&five);
    Run
    │ │ │ │ -
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: ?Sized + Debug, A: Allocator> Debug for Rc<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Default> Default for Rc<T>

    source§

    fn default() -> Rc<T>

    Creates a new Rc<T>, with the Default value for T.

    │ │ │ │ +
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: ?Sized + Debug, A: Allocator> Debug for Rc<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: Default> Default for Rc<T>

    source§

    fn default() -> Rc<T>

    Creates a new Rc<T>, with the Default value for T.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let x: Rc<i32> = Default::default();
│ │ │ │  assert_eq!(*x, 0);
    Run
    │ │ │ │ -
    source§

    impl<T: ?Sized, A: Allocator> Deref for Rc<T, A>

    §

    type Target = T

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &T

    Dereferences the value.
    source§

    impl<T: ?Sized + Display, A: Allocator> Display for Rc<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: ?Sized, A: Allocator> Drop for Rc<T, A>

    source§

    fn drop(&mut self)

    Drops the Rc.

    │ │ │ │ +
    source§

    impl<T: ?Sized, A: Allocator> Deref for Rc<T, A>

    §

    type Target = T

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &T

    Dereferences the value.
    source§

    impl<T: ?Sized + Display, A: Allocator> Display for Rc<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T: ?Sized, A: Allocator> Drop for Rc<T, A>

    source§

    fn drop(&mut self)

    Drops the Rc.

    │ │ │ │

    This will decrement the strong reference count. If the strong reference │ │ │ │ count reaches zero then the only other references (if any) are │ │ │ │ Weak, so we drop the inner value.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  struct Foo;
│ │ │ │ @@ -778,74 +778,74 @@
│ │ │ │  }
│ │ │ │  
│ │ │ │  let foo  = Rc::new(Foo);
│ │ │ │  let foo2 = Rc::clone(&foo);
│ │ │ │  
│ │ │ │  drop(foo);    // Doesn't print anything
│ │ │ │  drop(foo2);   // Prints "dropped!"
    Run
    │ │ │ │ -
    1.21.0 · source§

    impl<T: Clone> From<&[T]> for Rc<[T]>

    source§

    fn from(v: &[T]) -> Rc<[T]>

    Allocate a reference-counted slice and fill it by cloning v’s items.

    │ │ │ │ +
    1.21.0 · source§

    impl<T: Clone> From<&[T]> for Rc<[T]>

    source§

    fn from(v: &[T]) -> Rc<[T]>

    Allocate a reference-counted slice and fill it by cloning v’s items.

    │ │ │ │
    §Example
    │ │ │ │ 
    let original: &[i32] = &[1, 2, 3];
│ │ │ │  let shared: Rc<[i32]> = Rc::from(original);
│ │ │ │  assert_eq!(&[1, 2, 3], &shared[..]);
    Run
    │ │ │ │ -
    1.24.0 · source§

    impl From<&CStr> for Rc<CStr>

    source§

    fn from(s: &CStr) -> Rc<CStr>

    Converts a &CStr into a Rc<CStr>, │ │ │ │ +

    1.24.0 · source§

    impl From<&CStr> for Rc<CStr>

    source§

    fn from(s: &CStr) -> Rc<CStr>

    Converts a &CStr into a Rc<CStr>, │ │ │ │ by copying the contents into a newly allocated Rc.

    │ │ │ │ -
    1.21.0 · source§

    impl From<&str> for Rc<str>

    source§

    fn from(v: &str) -> Rc<str>

    Allocate a reference-counted string slice and copy v into it.

    │ │ │ │ +
    1.21.0 · source§

    impl From<&str> for Rc<str>

    source§

    fn from(v: &str) -> Rc<str>

    Allocate a reference-counted string slice and copy v into it.

    │ │ │ │
    §Example
    │ │ │ │ 
    let shared: Rc<str> = Rc::from("statue");
│ │ │ │  assert_eq!("statue", &shared[..]);
    Run
    │ │ │ │ -
    1.74.0 · source§

    impl<T, const N: usize> From<[T; N]> for Rc<[T]>

    source§

    fn from(v: [T; N]) -> Rc<[T]>

    Converts a [T; N] into an Rc<[T]>.

    │ │ │ │ +
    1.74.0 · source§

    impl<T, const N: usize> From<[T; N]> for Rc<[T]>

    source§

    fn from(v: [T; N]) -> Rc<[T]>

    Converts a [T; N] into an Rc<[T]>.

    │ │ │ │

    The conversion moves the array into a newly allocated Rc.

    │ │ │ │
    §Example
    │ │ │ │ 
    let original: [i32; 3] = [1, 2, 3];
│ │ │ │  let shared: Rc<[i32]> = Rc::from(original);
│ │ │ │  assert_eq!(&[1, 2, 3], &shared[..]);
    Run
    │ │ │ │ -
    1.21.0 · source§

    impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Rc<T, A>

    source§

    fn from(v: Box<T, A>) -> Rc<T, A>

    Move a boxed object to a new, reference counted, allocation.

    │ │ │ │ +
    1.21.0 · source§

    impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Rc<T, A>

    source§

    fn from(v: Box<T, A>) -> Rc<T, A>

    Move a boxed object to a new, reference counted, allocation.

    │ │ │ │
    §Example
    │ │ │ │ 
    let original: Box<i32> = Box::new(1);
│ │ │ │  let shared: Rc<i32> = Rc::from(original);
│ │ │ │  assert_eq!(1, *shared);
    Run
    │ │ │ │ -
    1.24.0 · source§

    impl From<CString> for Rc<CStr>

    source§

    fn from(s: CString) -> Rc<CStr>

    Converts a CString into an Rc<CStr> by moving the CString │ │ │ │ +

    1.24.0 · source§

    impl From<CString> for Rc<CStr>

    source§

    fn from(s: CString) -> Rc<CStr>

    Converts a CString into an Rc<CStr> by moving the CString │ │ │ │ data into a new Rc buffer.

    │ │ │ │ -
    1.45.0 · source§

    impl<'a, B> From<Cow<'a, B>> for Rc<B>
    where │ │ │ │ - B: ToOwned + ?Sized, │ │ │ │ - Rc<B>: From<&'a B> + From<B::Owned>,

    source§

    fn from(cow: Cow<'a, B>) -> Rc<B>

    Create a reference-counted pointer from │ │ │ │ +

    1.45.0 · source§

    impl<'a, B> From<Cow<'a, B>> for Rc<B>
    where │ │ │ │ + B: ToOwned + ?Sized, │ │ │ │ + Rc<B>: From<&'a B> + From<B::Owned>,

    source§

    fn from(cow: Cow<'a, B>) -> Rc<B>

    Create a reference-counted pointer from │ │ │ │ a clone-on-write pointer by copying its content.

    │ │ │ │
    §Example
    │ │ │ │ 
    let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
│ │ │ │  let shared: Rc<str> = Rc::from(cow);
│ │ │ │  assert_eq!("eggplant", &shared[..]);
    Run
    │ │ │ │ -
    source§

    impl<W: LocalWake + 'static> From<Rc<W>> for LocalWaker

    source§

    fn from(waker: Rc<W>) -> LocalWaker

    Use a Wake-able type as a LocalWaker.

    │ │ │ │ +
    source§

    impl<W: LocalWake + 'static> From<Rc<W>> for LocalWaker

    source§

    fn from(waker: Rc<W>) -> LocalWaker

    Use a Wake-able type as a LocalWaker.

    │ │ │ │

    No heap allocations or atomic operations are used for this conversion.

    │ │ │ │ -
    source§

    impl<W: LocalWake + 'static> From<Rc<W>> for RawWaker

    source§

    fn from(waker: Rc<W>) -> RawWaker

    Use a Wake-able type as a RawWaker.

    │ │ │ │ +
    source§

    impl<W: LocalWake + 'static> From<Rc<W>> for RawWaker

    source§

    fn from(waker: Rc<W>) -> RawWaker

    Use a Wake-able type as a RawWaker.

    │ │ │ │

    No heap allocations or atomic operations are used for this conversion.

    │ │ │ │ -
    1.62.0 · source§

    impl From<Rc<str>> for Rc<[u8]>

    source§

    fn from(rc: Rc<str>) -> Self

    Converts a reference-counted string slice into a byte slice.

    │ │ │ │ +
    1.62.0 · source§

    impl From<Rc<str>> for Rc<[u8]>

    source§

    fn from(rc: Rc<str>) -> Self

    Converts a reference-counted string slice into a byte slice.

    │ │ │ │
    §Example
    │ │ │ │ 
    let string: Rc<str> = Rc::from("eggplant");
│ │ │ │  let bytes: Rc<[u8]> = Rc::from(string);
│ │ │ │  assert_eq!("eggplant".as_bytes(), bytes.as_ref());
    Run
    │ │ │ │ -
    1.21.0 · source§

    impl From<String> for Rc<str>

    source§

    fn from(v: String) -> Rc<str>

    Allocate a reference-counted string slice and copy v into it.

    │ │ │ │ +
    1.21.0 · source§

    impl From<String> for Rc<str>

    source§

    fn from(v: String) -> Rc<str>

    Allocate a reference-counted string slice and copy v into it.

    │ │ │ │
    §Example
    │ │ │ │ 
    let original: String = "statue".to_owned();
│ │ │ │  let shared: Rc<str> = Rc::from(original);
│ │ │ │  assert_eq!("statue", &shared[..]);
    Run
    │ │ │ │ -
    1.6.0 · source§

    impl<T> From<T> for Rc<T>

    source§

    fn from(t: T) -> Self

    Converts a generic type T into an Rc<T>

    │ │ │ │ +
    1.6.0 · source§

    impl<T> From<T> for Rc<T>

    source§

    fn from(t: T) -> Self

    Converts a generic type T into an Rc<T>

    │ │ │ │

    The conversion allocates on the heap and moves t │ │ │ │ from the stack into it.

    │ │ │ │
    §Example
    │ │ │ │ 
    let x = 5;
│ │ │ │  let rc = Rc::new(5);
│ │ │ │  
│ │ │ │  assert_eq!(Rc::from(x), rc);
    Run
    │ │ │ │ -
    1.21.0 · source§

    impl<T, A: Allocator> From<Vec<T, A>> for Rc<[T], A>

    source§

    fn from(v: Vec<T, A>) -> Rc<[T], A>

    Allocate a reference-counted slice and move v’s items into it.

    │ │ │ │ +
    1.21.0 · source§

    impl<T, A: Allocator> From<Vec<T, A>> for Rc<[T], A>

    source§

    fn from(v: Vec<T, A>) -> Rc<[T], A>

    Allocate a reference-counted slice and move v’s items into it.

    │ │ │ │
    §Example
    │ │ │ │ 
    let unique: Vec<i32> = vec![1, 2, 3];
│ │ │ │  let shared: Rc<[i32]> = Rc::from(unique);
│ │ │ │  assert_eq!(&[1, 2, 3], &shared[..]);
    Run
    │ │ │ │ -
    1.37.0 · source§

    impl<T> FromIterator<T> for Rc<[T]>

    source§

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

    Takes each element in the Iterator and collects it into an Rc<[T]>.

    │ │ │ │ +
    1.37.0 · source§

    impl<T> FromIterator<T> for Rc<[T]>

    source§

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

    Takes each element in the Iterator and collects it into an Rc<[T]>.

    │ │ │ │
    §Performance characteristics
    §The general case
    │ │ │ │

    In the general case, collecting into Rc<[T]> is done by first │ │ │ │ collecting into a Vec<T>. That is, when writing the following:

    │ │ │ │ │ │ │ │ 
    let evens: Rc<[u8]> = (0..10).filter(|&x| x % 2 == 0).collect();
    Run
    │ │ │ │

    this behaves as if we wrote:

    │ │ │ │ │ │ │ │ @@ -855,99 +855,99 @@ │ │ │ │

    This will allocate as many times as needed for constructing the Vec<T> │ │ │ │ and then it will allocate once for turning the Vec<T> into the Rc<[T]>.

    │ │ │ │
    §Iterators of known length
    │ │ │ │

    When your Iterator implements TrustedLen and is of an exact size, │ │ │ │ a single allocation will be made for the Rc<[T]>. For example:

    │ │ │ │ │ │ │ │ 
    let evens: Rc<[u8]> = (0..10).collect(); // Just a single allocation happens here.
    Run
    │ │ │ │ -
    source§

    impl<T: ?Sized + Hash, A: Allocator> Hash for Rc<T, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ - H: Hasher, │ │ │ │ - Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<T: ?Sized + Ord, A: Allocator> Ord for Rc<T, A>

    source§

    fn cmp(&self, other: &Rc<T, A>) -> Ordering

    Comparison for two Rcs.

    │ │ │ │ +
    source§

    impl<T: ?Sized + Hash, A: Allocator> Hash for Rc<T, A>

    source§

    fn hash<H: Hasher>(&self, state: &mut H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where │ │ │ │ + H: Hasher, │ │ │ │ + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<T: ?Sized + Ord, A: Allocator> Ord for Rc<T, A>

    source§

    fn cmp(&self, other: &Rc<T, A>) -> Ordering

    Comparison for two Rcs.

    │ │ │ │

    The two are compared by calling cmp() on their inner values.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  use std::cmp::Ordering;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  
│ │ │ │  assert_eq!(Ordering::Less, five.cmp(&Rc::new(6)));
    Run
    │ │ │ │ -
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ - Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ - Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Rc<T, A>

    source§

    fn eq(&self, other: &Rc<T, A>) -> bool

    Equality for two Rcs.

    │ │ │ │ +
    1.21.0 · source§

    fn max(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Self
    where │ │ │ │ + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Self
    where │ │ │ │ + Self: Sized + PartialOrd,

    Restrict a value to a certain interval. Read more
    source§

    impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Rc<T, A>

    source§

    fn eq(&self, other: &Rc<T, A>) -> bool

    Equality for two Rcs.

    │ │ │ │

    Two Rcs are equal if their inner values are equal, even if they are │ │ │ │ stored in different allocation.

    │ │ │ │

    If T also implements Eq (implying reflexivity of equality), │ │ │ │ two Rcs that point to the same allocation are │ │ │ │ always equal.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  
│ │ │ │  assert!(five == Rc::new(5));
    Run
    │ │ │ │ -
    source§

    fn ne(&self, other: &Rc<T, A>) -> bool

    Inequality for two Rcs.

    │ │ │ │ +
    source§

    fn ne(&self, other: &Rc<T, A>) -> bool

    Inequality for two Rcs.

    │ │ │ │

    Two Rcs are not equal if their inner values are not equal.

    │ │ │ │

    If T also implements Eq (implying reflexivity of equality), │ │ │ │ two Rcs that point to the same allocation are │ │ │ │ always equal.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  
│ │ │ │  assert!(five != Rc::new(6));
    Run
    │ │ │ │ -
    source§

    impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Rc<T, A>

    source§

    fn partial_cmp(&self, other: &Rc<T, A>) -> Option<Ordering>

    Partial comparison for two Rcs.

    │ │ │ │ +
    source§

    impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Rc<T, A>

    source§

    fn partial_cmp(&self, other: &Rc<T, A>) -> Option<Ordering>

    Partial comparison for two Rcs.

    │ │ │ │

    The two are compared by calling partial_cmp() on their inner values.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  use std::cmp::Ordering;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  
│ │ │ │  assert_eq!(Some(Ordering::Less), five.partial_cmp(&Rc::new(6)));
    Run
    │ │ │ │ -
    source§

    fn lt(&self, other: &Rc<T, A>) -> bool

    Less-than comparison for two Rcs.

    │ │ │ │ +
    source§

    fn lt(&self, other: &Rc<T, A>) -> bool

    Less-than comparison for two Rcs.

    │ │ │ │

    The two are compared by calling < on their inner values.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  
│ │ │ │  assert!(five < Rc::new(6));
    Run
    │ │ │ │ -
    source§

    fn le(&self, other: &Rc<T, A>) -> bool

    ‘Less than or equal to’ comparison for two Rcs.

    │ │ │ │ +
    source§

    fn le(&self, other: &Rc<T, A>) -> bool

    ‘Less than or equal to’ comparison for two Rcs.

    │ │ │ │

    The two are compared by calling <= on their inner values.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  
│ │ │ │  assert!(five <= Rc::new(5));
    Run
    │ │ │ │ -
    source§

    fn gt(&self, other: &Rc<T, A>) -> bool

    Greater-than comparison for two Rcs.

    │ │ │ │ +
    source§

    fn gt(&self, other: &Rc<T, A>) -> bool

    Greater-than comparison for two Rcs.

    │ │ │ │

    The two are compared by calling > on their inner values.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  
│ │ │ │  assert!(five > Rc::new(4));
    Run
    │ │ │ │ -
    source§

    fn ge(&self, other: &Rc<T, A>) -> bool

    ‘Greater than or equal to’ comparison for two Rcs.

    │ │ │ │ +
    source§

    fn ge(&self, other: &Rc<T, A>) -> bool

    ‘Greater than or equal to’ comparison for two Rcs.

    │ │ │ │

    The two are compared by calling >= on their inner values.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  
│ │ │ │  assert!(five >= Rc::new(5));
    Run
    │ │ │ │ -
    source§

    impl<T: ?Sized, A: Allocator> Pointer for Rc<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    1.43.0 · source§

    impl<T, const N: usize> TryFrom<Rc<[T]>> for Rc<[T; N]>

    §

    type Error = Rc<[T]>

    The type returned in the event of a conversion error.
    source§

    fn try_from(boxed_slice: Rc<[T]>) -> Result<Self, Self::Error>

    Performs the conversion.
    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Rc<U, A>> for Rc<T, A>

    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Rc<U>> for Rc<T>

    source§

    impl<T: ?Sized + Eq, A: Allocator> Eq for Rc<T, A>

    1.58.0 · source§

    impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> RefUnwindSafe for Rc<T, A>

    source§

    impl<T: ?Sized, A: Allocator> !Send for Rc<T, A>

    source§

    impl<T: ?Sized, A: Allocator> !Sync for Rc<T, A>

    1.33.0 · source§

    impl<T: ?Sized, A: Allocator> Unpin for Rc<T, A>

    1.9.0 · source§

    impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> UnwindSafe for Rc<T, A>

    Auto Trait Implementations§

    §

    impl<T: ?Sized, A> Freeze for Rc<T, A>
    where │ │ │ │ - A: Freeze,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<!> for T

    source§

    fn from(t: !) -> T

    Converts to this type from the input type.
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +
    source§

    impl<T: ?Sized, A: Allocator> Pointer for Rc<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    1.43.0 · source§

    impl<T, const N: usize> TryFrom<Rc<[T]>> for Rc<[T; N]>

    §

    type Error = Rc<[T]>

    The type returned in the event of a conversion error.
    source§

    fn try_from(boxed_slice: Rc<[T]>) -> Result<Self, Self::Error>

    Performs the conversion.
    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Rc<U, A>> for Rc<T, A>

    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Rc<U>> for Rc<T>

    source§

    impl<T: ?Sized + Eq, A: Allocator> Eq for Rc<T, A>

    1.58.0 · source§

    impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> RefUnwindSafe for Rc<T, A>

    source§

    impl<T: ?Sized, A: Allocator> !Send for Rc<T, A>

    source§

    impl<T: ?Sized, A: Allocator> !Sync for Rc<T, A>

    1.33.0 · source§

    impl<T: ?Sized, A: Allocator> Unpin for Rc<T, A>

    1.9.0 · source§

    impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> UnwindSafe for Rc<T, A>

    Auto Trait Implementations§

    §

    impl<T: ?Sized, A> Freeze for Rc<T, A>
    where │ │ │ │ + A: Freeze,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<!> for T

    source§

    fn from(t: !) -> T

    Converts to this type from the input type.
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/rc/struct.UniqueRc.html │ │ │ │ @@ -22,35 +22,35 @@ │ │ │ │ }); │ │ │ │ rc.me = UniqueRc::downgrade(&rc); │ │ │ │ Some(UniqueRc::into_rc(rc)) │ │ │ │ } │ │ │ │ │ │ │ │ create_gadget().unwrap();Run │ │ │ │

    An advantage of using UniqueRc over Rc::new_cyclic to build cyclic data structures is that │ │ │ │ -Rc::new_cyclic’s data_fn parameter cannot be async or return a Result. As shown in the │ │ │ │ +Rc::new_cyclic’s data_fn parameter cannot be async or return a Result. As shown in the │ │ │ │ previous example, UniqueRc allows for more flexibility in the construction of cyclic data, │ │ │ │ including fallible or async constructors.

    │ │ │ │

    Implementations§

    source§

    impl<T> UniqueRc<T>

    source

    pub fn new(value: T) -> Self

    🔬This is a nightly-only experimental API. (unique_rc_arc #112566)

    Creates a new UniqueRc

    │ │ │ │

    Weak references to this UniqueRc can be created with UniqueRc::downgrade. Upgrading │ │ │ │ these weak references will fail before the UniqueRc has been converted into an Rc. │ │ │ │ After converting the UniqueRc into an Rc, any weak references created beforehand will │ │ │ │ point to the new Rc.

    │ │ │ │ -
    source

    pub fn downgrade(this: &Self) -> Weak<T>

    🔬This is a nightly-only experimental API. (unique_rc_arc #112566)

    Creates a new weak reference to the UniqueRc

    │ │ │ │ +
    source

    pub fn downgrade(this: &Self) -> Weak<T>

    🔬This is a nightly-only experimental API. (unique_rc_arc #112566)

    Creates a new weak reference to the UniqueRc

    │ │ │ │

    Attempting to upgrade this weak reference will fail before the UniqueRc has been converted │ │ │ │ to a Rc using UniqueRc::into_rc.

    │ │ │ │
    source

    pub fn into_rc(this: Self) -> Rc<T>

    🔬This is a nightly-only experimental API. (unique_rc_arc #112566)

    Converts the UniqueRc into a regular Rc

    │ │ │ │

    This consumes the UniqueRc and returns a regular Rc that contains the value that │ │ │ │ is passed to into_rc.

    │ │ │ │

    Any weak references created before this method is called can now be upgraded to strong │ │ │ │ references.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: Debug> Debug for UniqueRc<T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T> Deref for UniqueRc<T>

    §

    type Target = T

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &T

    Dereferences the value.
    source§

    impl<T> DerefMut for UniqueRc<T>

    source§

    fn deref_mut(&mut self) -> &mut T

    Mutably dereferences the value.
    source§

    impl<T> Drop for UniqueRc<T>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more

    Auto Trait Implementations§

    §

    impl<T> Freeze for UniqueRc<T>

    §

    impl<T> !RefUnwindSafe for UniqueRc<T>

    §

    impl<T> !Send for UniqueRc<T>

    §

    impl<T> !Sync for UniqueRc<T>

    §

    impl<T> Unpin for UniqueRc<T>
    where │ │ │ │ - T: Unpin,

    §

    impl<T> !UnwindSafe for UniqueRc<T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: Debug> Debug for UniqueRc<T>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl<T> Deref for UniqueRc<T>

    §

    type Target = T

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &T

    Dereferences the value.
    source§

    impl<T> DerefMut for UniqueRc<T>

    source§

    fn deref_mut(&mut self) -> &mut T

    Mutably dereferences the value.
    source§

    impl<T> Drop for UniqueRc<T>

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more

    Auto Trait Implementations§

    §

    impl<T> Freeze for UniqueRc<T>

    §

    impl<T> !RefUnwindSafe for UniqueRc<T>

    §

    impl<T> !Send for UniqueRc<T>

    §

    impl<T> !Sync for UniqueRc<T>

    §

    impl<T> Unpin for UniqueRc<T>
    where │ │ │ │ + T: Unpin,

    §

    impl<T> !UnwindSafe for UniqueRc<T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/rc/struct.Weak.html │ │ │ │ @@ -1,39 +1,39 @@ │ │ │ │ Weak in alloc::rc - Rust
    │ │ │ │ -

    Struct alloc::rc::Weak

    1.4.0 · source · 
    pub struct Weak<T: ?Sized, A: Allocator = Global> { /* private fields */ }
    Expand description

    Weak is a version of Rc that holds a non-owning reference to the │ │ │ │ +

    Struct alloc::rc::Weak

    1.4.0 · source · 
    pub struct Weak<T: ?Sized, A: Allocator = Global> { /* private fields */ }
    Expand description

    Weak is a version of Rc that holds a non-owning reference to the │ │ │ │ managed allocation. The allocation is accessed by calling upgrade on the Weak │ │ │ │ -pointer, which returns an Option<Rc<T>>.

    │ │ │ │ +pointer, which returns an Option<Rc<T>>.

    │ │ │ │

    Since a Weak reference does not count towards ownership, it will not │ │ │ │ prevent the value stored in the allocation from being dropped, and Weak itself makes no │ │ │ │ -guarantees about the value still being present. Thus it may return None │ │ │ │ +guarantees about the value still being present. Thus it may return None │ │ │ │ when upgraded. Note however that a Weak reference does prevent the allocation │ │ │ │ itself (the backing store) from being deallocated.

    │ │ │ │

    A Weak pointer is useful for keeping a temporary reference to the allocation │ │ │ │ managed by Rc without preventing its inner value from being dropped. It is also used to │ │ │ │ prevent circular references between Rc pointers, since mutual owning references │ │ │ │ would never allow either Rc to be dropped. For example, a tree could │ │ │ │ have strong Rc pointers from parent nodes to children, and Weak │ │ │ │ pointers from children back to their parents.

    │ │ │ │

    The typical way to obtain a Weak pointer is to call Rc::downgrade.

    │ │ │ │

    Implementations§

    source§

    impl<T> Weak<T>

    1.10.0 (const: 1.73.0) · source

    pub const fn new() -> Weak<T>

    Constructs a new Weak<T>, without allocating any memory. │ │ │ │ -Calling upgrade on the return value always gives None.

    │ │ │ │ +Calling upgrade on the return value always gives None.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Weak;
│ │ │ │  
│ │ │ │  let empty: Weak<i64> = Weak::new();
│ │ │ │  assert!(empty.upgrade().is_none());
    Run
    │ │ │ │
    source§

    impl<T, A: Allocator> Weak<T, A>

    source

    pub fn new_in(alloc: A) -> Weak<T, A>

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Constructs a new Weak<T>, without allocating any memory, technically in the provided │ │ │ │ allocator. │ │ │ │ -Calling upgrade on the return value always gives None.

    │ │ │ │ +Calling upgrade on the return value always gives None.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Weak;
│ │ │ │  
│ │ │ │  let empty: Weak<i64> = Weak::new();
│ │ │ │  assert!(empty.upgrade().is_none());
    Run
    │ │ │ │ -
    source§

    impl<T: ?Sized> Weak<T>

    1.45.0 · source

    pub unsafe fn from_raw(ptr: *const T) -> Self

    Converts a raw pointer previously created by into_raw back into Weak<T>.

    │ │ │ │ +
    source§

    impl<T: ?Sized> Weak<T>

    1.45.0 · source

    pub unsafe fn from_raw(ptr: *const T) -> Self

    Converts a raw pointer previously created by into_raw back into Weak<T>.

    │ │ │ │

    This can be used to safely get a strong reference (by calling upgrade │ │ │ │ later) or to deallocate the weak count by dropping the Weak<T>.

    │ │ │ │

    It takes ownership of one weak reference (with the exception of pointers created by new, │ │ │ │ as these don’t own anything; the method still works on them).

    │ │ │ │
    §Safety
    │ │ │ │

    The pointer must have originated from the into_raw and must still own its potential │ │ │ │ weak reference, and ptr must point to a block of memory allocated by the global allocator.

    │ │ │ │ @@ -54,17 +54,17 @@ │ │ │ │ assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap()); │ │ │ │ assert_eq!(1, Rc::weak_count(&strong)); │ │ │ │ │ │ │ │ drop(strong); │ │ │ │ │ │ │ │ // Decrement the last weak count. │ │ │ │ assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none());Run
    │ │ │ │ -
    source§

    impl<T: ?Sized, A: Allocator> Weak<T, A>

    1.45.0 · source

    pub fn as_ptr(&self) -> *const T

    Returns a raw pointer to the object T pointed to by this Weak<T>.

    │ │ │ │ +
    source§

    impl<T: ?Sized, A: Allocator> Weak<T, A>

    1.45.0 · source

    pub fn as_ptr(&self) -> *const T

    Returns a raw pointer to the object T pointed to by this Weak<T>.

    │ │ │ │

    The pointer is valid only if there are some strong references. The pointer may be dangling, │ │ │ │ -unaligned or even null otherwise.

    │ │ │ │ +unaligned or even null otherwise.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  use std::ptr;
│ │ │ │  
│ │ │ │  let strong = Rc::new("hello".to_owned());
│ │ │ │  let weak = Rc::downgrade(&strong);
│ │ │ │  // Both point to the same object
│ │ │ │ @@ -72,15 +72,15 @@
│ │ │ │  // The strong here keeps it alive, so we can still access the object.
│ │ │ │  assert_eq!("hello", unsafe { &*weak.as_ptr() });
│ │ │ │  
│ │ │ │  drop(strong);
│ │ │ │  // But not any more. We can do weak.as_ptr(), but accessing the pointer would lead to
│ │ │ │  // undefined behaviour.
│ │ │ │  // assert_eq!("hello", unsafe { &*weak.as_ptr() });
    Run
    │ │ │ │ -
    1.45.0 · source

    pub fn into_raw(self) -> *const T

    Consumes the Weak<T> and turns it into a raw pointer.

    │ │ │ │ +
    1.45.0 · source

    pub fn into_raw(self) -> *const T

    Consumes the Weak<T> and turns it into a raw pointer.

    │ │ │ │

    This converts the weak pointer into a raw pointer, while still preserving the ownership of │ │ │ │ one weak reference (the weak count is not modified by this operation). It can be turned │ │ │ │ back into the Weak<T> with from_raw.

    │ │ │ │

    The same restrictions of accessing the target of the pointer as with │ │ │ │ as_ptr apply.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::{Rc, Weak};
│ │ │ │ @@ -90,16 +90,16 @@
│ │ │ │  let raw = weak.into_raw();
│ │ │ │  
│ │ │ │  assert_eq!(1, Rc::weak_count(&strong));
│ │ │ │  assert_eq!("hello", unsafe { &*raw });
│ │ │ │  
│ │ │ │  drop(unsafe { Weak::from_raw(raw) });
│ │ │ │  assert_eq!(0, Rc::weak_count(&strong));
    Run
    │ │ │ │ -
    source

    pub fn into_raw_and_alloc(self) -> (*const T, A)
    where │ │ │ │ - A: Clone,

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Consumes the Weak<T> and turns it into a raw pointer.

    │ │ │ │ +
    source

    pub fn into_raw_and_alloc(self) -> (*const T, A)
    where │ │ │ │ + A: Clone,

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Consumes the Weak<T> and turns it into a raw pointer.

    │ │ │ │

    This converts the weak pointer into a raw pointer, while still preserving the ownership of │ │ │ │ one weak reference (the weak count is not modified by this operation). It can be turned │ │ │ │ back into the Weak<T> with from_raw.

    │ │ │ │

    The same restrictions of accessing the target of the pointer as with │ │ │ │ as_ptr apply.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::{Rc, Weak};
│ │ │ │ @@ -109,15 +109,15 @@
│ │ │ │  let raw = weak.into_raw();
│ │ │ │  
│ │ │ │  assert_eq!(1, Rc::weak_count(&strong));
│ │ │ │  assert_eq!("hello", unsafe { &*raw });
│ │ │ │  
│ │ │ │  drop(unsafe { Weak::from_raw(raw) });
│ │ │ │  assert_eq!(0, Rc::weak_count(&strong));
    Run
    │ │ │ │ -
    source

    pub unsafe fn from_raw_in(ptr: *const T, alloc: A) -> Self

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Converts a raw pointer previously created by into_raw back into Weak<T>.

    │ │ │ │ +
    source

    pub unsafe fn from_raw_in(ptr: *const T, alloc: A) -> Self

    🔬This is a nightly-only experimental API. (allocator_api #32838)

    Converts a raw pointer previously created by into_raw back into Weak<T>.

    │ │ │ │

    This can be used to safely get a strong reference (by calling upgrade │ │ │ │ later) or to deallocate the weak count by dropping the Weak<T>.

    │ │ │ │

    It takes ownership of one weak reference (with the exception of pointers created by new, │ │ │ │ as these don’t own anything; the method still works on them).

    │ │ │ │
    §Safety
    │ │ │ │

    The pointer must have originated from the into_raw and must still own its potential │ │ │ │ weak reference, and ptr must point to a block of memory allocated by alloc.

    │ │ │ │ @@ -138,18 +138,18 @@ │ │ │ │ assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap()); │ │ │ │ assert_eq!(1, Rc::weak_count(&strong)); │ │ │ │ │ │ │ │ drop(strong); │ │ │ │ │ │ │ │ // Decrement the last weak count. │ │ │ │ assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none());Run
    │ │ │ │ -
    source

    pub fn upgrade(&self) -> Option<Rc<T, A>>
    where │ │ │ │ - A: Clone,

    Attempts to upgrade the Weak pointer to an Rc, delaying │ │ │ │ +

    source

    pub fn upgrade(&self) -> Option<Rc<T, A>>
    where │ │ │ │ + A: Clone,

    Attempts to upgrade the Weak pointer to an Rc, delaying │ │ │ │ dropping of the inner value if successful.

    │ │ │ │ -

    Returns None if the inner value has since been dropped.

    │ │ │ │ +

    Returns None if the inner value has since been dropped.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │  
│ │ │ │  let five = Rc::new(5);
│ │ │ │  
│ │ │ │  let weak_five = Rc::downgrade(&five);
│ │ │ │  
│ │ │ │ @@ -157,19 +157,19 @@
│ │ │ │  assert!(strong_five.is_some());
│ │ │ │  
│ │ │ │  // Destroy all strong pointers.
│ │ │ │  drop(strong_five);
│ │ │ │  drop(five);
│ │ │ │  
│ │ │ │  assert!(weak_five.upgrade().is_none());
    Run
    │ │ │ │ -
    1.41.0 · source

    pub fn strong_count(&self) -> usize

    Gets the number of strong (Rc) pointers pointing to this allocation.

    │ │ │ │ +
    1.41.0 · source

    pub fn strong_count(&self) -> usize

    Gets the number of strong (Rc) pointers pointing to this allocation.

    │ │ │ │

    If self was created using Weak::new, this will return 0.

    │ │ │ │ -
    1.41.0 · source

    pub fn weak_count(&self) -> usize

    Gets the number of Weak pointers pointing to this allocation.

    │ │ │ │ +
    1.41.0 · source

    pub fn weak_count(&self) -> usize

    Gets the number of Weak pointers pointing to this allocation.

    │ │ │ │

    If no strong pointers remain, this will return zero.

    │ │ │ │ -
    1.39.0 · source

    pub fn ptr_eq(&self, other: &Self) -> bool

    Returns true if the two Weaks point to the same allocation similar to ptr::eq, or if │ │ │ │ +

    1.39.0 · source

    pub fn ptr_eq(&self, other: &Self) -> bool

    Returns true if the two Weaks point to the same allocation similar to ptr::eq, or if │ │ │ │ both don’t point to any allocation (because they were created with Weak::new()). However, │ │ │ │ this function ignores the metadata of dyn Trait pointers.

    │ │ │ │
    §Notes
    │ │ │ │

    Since this compares pointers it means that Weak::new() will equal each │ │ │ │ other, even though they don’t point to any allocation.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Rc;
│ │ │ │ @@ -191,29 +191,29 @@
│ │ │ │  let first = Weak::new();
│ │ │ │  let second = Weak::new();
│ │ │ │  assert!(first.ptr_eq(&second));
│ │ │ │  
│ │ │ │  let third_rc = Rc::new(());
│ │ │ │  let third = Rc::downgrade(&third_rc);
│ │ │ │  assert!(!first.ptr_eq(&third));
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T: ?Sized, A: Allocator + Clone> Clone for Weak<T, A>

    source§

    fn clone(&self) -> Weak<T, A>

    Makes a clone of the Weak pointer that points to the same allocation.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<T: ?Sized, A: Allocator + Clone> Clone for Weak<T, A>

    source§

    fn clone(&self) -> Weak<T, A>

    Makes a clone of the Weak pointer that points to the same allocation.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::{Rc, Weak};
│ │ │ │  
│ │ │ │  let weak_five = Rc::downgrade(&Rc::new(5));
│ │ │ │  
│ │ │ │  let _ = Weak::clone(&weak_five);
    Run
    │ │ │ │ -
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: ?Sized, A: Allocator> Debug for Weak<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.10.0 · source§

    impl<T> Default for Weak<T>

    source§

    fn default() -> Weak<T>

    Constructs a new Weak<T>, without allocating any memory. │ │ │ │ -Calling upgrade on the return value always gives None.

    │ │ │ │ +
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T: ?Sized, A: Allocator> Debug for Weak<T, A>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    1.10.0 · source§

    impl<T> Default for Weak<T>

    source§

    fn default() -> Weak<T>

    Constructs a new Weak<T>, without allocating any memory. │ │ │ │ +Calling upgrade on the return value always gives None.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::Weak;
│ │ │ │  
│ │ │ │  let empty: Weak<i64> = Default::default();
│ │ │ │  assert!(empty.upgrade().is_none());
    Run
    │ │ │ │ -
    source§

    impl<T: ?Sized, A: Allocator> Drop for Weak<T, A>

    source§

    fn drop(&mut self)

    Drops the Weak pointer.

    │ │ │ │ +
    source§

    impl<T: ?Sized, A: Allocator> Drop for Weak<T, A>

    source§

    fn drop(&mut self)

    Drops the Weak pointer.

    │ │ │ │
    §Examples
    │ │ │ │ 
    use std::rc::{Rc, Weak};
│ │ │ │  
│ │ │ │  struct Foo;
│ │ │ │  
│ │ │ │  impl Drop for Foo {
│ │ │ │      fn drop(&mut self) {
│ │ │ │ @@ -225,21 +225,21 @@
│ │ │ │  let weak_foo = Rc::downgrade(&foo);
│ │ │ │  let other_weak_foo = Weak::clone(&weak_foo);
│ │ │ │  
│ │ │ │  drop(weak_foo);   // Doesn't print anything
│ │ │ │  drop(foo);        // Prints "dropped!"
│ │ │ │  
│ │ │ │  assert!(other_weak_foo.upgrade().is_none());
    Run
    │ │ │ │ -
    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Weak<U, A>> for Weak<T, A>

    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T>

    source§

    impl<T: ?Sized, A: Allocator> !Send for Weak<T, A>

    source§

    impl<T: ?Sized, A: Allocator> !Sync for Weak<T, A>

    Auto Trait Implementations§

    §

    impl<T: ?Sized, A> Freeze for Weak<T, A>
    where │ │ │ │ - A: Freeze,

    §

    impl<T, A = Global> !RefUnwindSafe for Weak<T, A>

    §

    impl<T: ?Sized, A> Unpin for Weak<T, A>
    where │ │ │ │ - A: Unpin,

    §

    impl<T, A = Global> !UnwindSafe for Weak<T, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +
    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Weak<U, A>> for Weak<T, A>

    source§

    impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T>

    source§

    impl<T: ?Sized, A: Allocator> !Send for Weak<T, A>

    source§

    impl<T: ?Sized, A: Allocator> !Sync for Weak<T, A>

    Auto Trait Implementations§

    §

    impl<T: ?Sized, A> Freeze for Weak<T, A>
    where │ │ │ │ + A: Freeze,

    §

    impl<T, A = Global> !RefUnwindSafe for Weak<T, A>

    §

    impl<T: ?Sized, A> Unpin for Weak<T, A>
    where │ │ │ │ + A: Unpin,

    §

    impl<T, A = Global> !UnwindSafe for Weak<T, A>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_mut.html │ │ │ │ @@ -1,3 +1,3 @@ │ │ │ │ from_mut in alloc::slice - Rust
    │ │ │ │ -

    Function alloc::slice::from_mut

    1.28.0 (const: unstable) · source · 
    pub fn from_mut<T>(s: &mut T) -> &mut [T]
    Expand description

    Converts a reference to T into a slice of length 1 (without copying).

    │ │ │ │ +

    Function alloc::slice::from_mut

    1.28.0 (const: unstable) · source · 
    pub fn from_mut<T>(s: &mut T) -> &mut [T]
    Expand description

    Converts a reference to T into a slice of length 1 (without copying).

    │ │ │ │
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_mut_ptr_range.html │ │ │ │ @@ -1,23 +1,23 @@ │ │ │ │ from_mut_ptr_range in alloc::slice - Rust
    │ │ │ │ -

    Function alloc::slice::from_mut_ptr_range

    const: unstable · source · 
    pub unsafe fn from_mut_ptr_range<'a, T>(range: Range<*mut T>) -> &'a mut [T]
    🔬This is a nightly-only experimental API. (slice_from_ptr_range #89792)
    Expand description

    Forms a mutable slice from a pointer range.

    │ │ │ │ +

    Function alloc::slice::from_mut_ptr_range

    const: unstable · source · 
    pub unsafe fn from_mut_ptr_range<'a, T>(range: Range<*mut T>) -> &'a mut [T]
    🔬This is a nightly-only experimental API. (slice_from_ptr_range #89792)
    Expand description

    Forms a mutable slice from a pointer range.

    │ │ │ │

    This is the same functionality as from_ptr_range, except that a │ │ │ │ mutable slice is returned.

    │ │ │ │

    This function is useful for interacting with foreign interfaces which │ │ │ │ use two pointers to refer to a range of elements in memory, as is │ │ │ │ common in C++.

    │ │ │ │

    §Safety

    │ │ │ │

    Behavior is undefined if any of the following conditions are violated:

    │ │ │ │
      │ │ │ │
    • │ │ │ │ -

      The start pointer of the range must be a valid and properly aligned pointer │ │ │ │ +

      The start pointer of the range must be a valid and properly aligned pointer │ │ │ │ to the first element of a slice.

      │ │ │ │
      • │ │ │ │
    • │ │ │ │ -

      The end pointer must be a valid and properly aligned pointer to one past │ │ │ │ +

      The end pointer must be a valid and properly aligned pointer to one past │ │ │ │ the last element, such that the offset from the end to the start pointer is │ │ │ │ the length of the slice.

      │ │ │ │
      • │ │ │ │
    • │ │ │ │

      The entire memory range of this slice must be contained within a single allocated object! │ │ │ │ Slices can never span across multiple allocated objects.

      │ │ │ │
      • │ │ │ │ @@ -28,18 +28,18 @@ │ │ │ │

      The memory referenced by the returned slice must not be accessed through any other pointer │ │ │ │ (not derived from the return value) for the duration of lifetime 'a. │ │ │ │ Both read and write accesses are forbidden.

      │ │ │ │ │ │ │ │
    • │ │ │ │

      The total length of the range must be no larger than isize::MAX, │ │ │ │ and adding that size to data must not “wrap around” the address space. │ │ │ │ -See the safety documentation of pointer::offset.

      │ │ │ │ +See the safety documentation of pointer::offset.

      │ │ │ │
      • │ │ │ │
    │ │ │ │ -

    Note that a range created from slice::as_mut_ptr_range fulfills these requirements.

    │ │ │ │ +

    Note that a range created from slice::as_mut_ptr_range fulfills these requirements.

    │ │ │ │

    §Panics

    │ │ │ │

    This function panics if T is a Zero-Sized Type (“ZST”).

    │ │ │ │

    §Caveat

    │ │ │ │

    The lifetime for the returned slice is inferred from its usage. To │ │ │ │ prevent accidental misuse, it’s suggested to tie the lifetime to whichever │ │ │ │ source lifetime is safe in the context, such as by providing a helper │ │ │ │ function taking the lifetime of a host value for the slice, or by explicit │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_ptr_range.html │ │ │ │ @@ -1,21 +1,21 @@ │ │ │ │ from_ptr_range in alloc::slice - Rust

    │ │ │ │ -

    Function alloc::slice::from_ptr_range

    const: unstable · source · 
    pub unsafe fn from_ptr_range<'a, T>(range: Range<*const T>) -> &'a [T]
    🔬This is a nightly-only experimental API. (slice_from_ptr_range #89792)
    Expand description

    Forms a slice from a pointer range.

    │ │ │ │ +

    Function alloc::slice::from_ptr_range

    const: unstable · source · 
    pub unsafe fn from_ptr_range<'a, T>(range: Range<*const T>) -> &'a [T]
    🔬This is a nightly-only experimental API. (slice_from_ptr_range #89792)
    Expand description

    Forms a slice from a pointer range.

    │ │ │ │

    This function is useful for interacting with foreign interfaces which │ │ │ │ use two pointers to refer to a range of elements in memory, as is │ │ │ │ common in C++.

    │ │ │ │

    §Safety

    │ │ │ │

    Behavior is undefined if any of the following conditions are violated:

    │ │ │ │
      │ │ │ │
    • │ │ │ │ -

      The start pointer of the range must be a valid and properly aligned pointer │ │ │ │ +

      The start pointer of the range must be a valid and properly aligned pointer │ │ │ │ to the first element of a slice.

      │ │ │ │
      • │ │ │ │
    • │ │ │ │ -

      The end pointer must be a valid and properly aligned pointer to one past │ │ │ │ +

      The end pointer must be a valid and properly aligned pointer to one past │ │ │ │ the last element, such that the offset from the end to the start pointer is │ │ │ │ the length of the slice.

      │ │ │ │
      • │ │ │ │
    • │ │ │ │

      The entire memory range of this slice must be contained within a single allocated object! │ │ │ │ Slices can never span across multiple allocated objects.

      │ │ │ │
      • │ │ │ │ @@ -25,18 +25,18 @@ │ │ │ │
    • │ │ │ │

      The memory referenced by the returned slice must not be mutated for the duration │ │ │ │ of lifetime 'a, except inside an UnsafeCell.

      │ │ │ │
      • │ │ │ │
    • │ │ │ │

      The total length of the range must be no larger than isize::MAX, │ │ │ │ and adding that size to data must not “wrap around” the address space. │ │ │ │ -See the safety documentation of pointer::offset.

      │ │ │ │ +See the safety documentation of pointer::offset.

      │ │ │ │
      • │ │ │ │
    │ │ │ │ -

    Note that a range created from slice::as_ptr_range fulfills these requirements.

    │ │ │ │ +

    Note that a range created from slice::as_ptr_range fulfills these requirements.

    │ │ │ │

    §Panics

    │ │ │ │

    This function panics if T is a Zero-Sized Type (“ZST”).

    │ │ │ │

    §Caveat

    │ │ │ │

    The lifetime for the returned slice is inferred from its usage. To │ │ │ │ prevent accidental misuse, it’s suggested to tie the lifetime to whichever │ │ │ │ source lifetime is safe in the context, such as by providing a helper │ │ │ │ function taking the lifetime of a host value for the slice, or by explicit │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_raw_parts.html │ │ │ │ @@ -1,38 +1,38 @@ │ │ │ │ from_raw_parts in alloc::slice - Rust

    │ │ │ │ -

    Function alloc::slice::from_raw_parts

    1.0.0 (const: 1.64.0) · source · 
    pub const unsafe fn from_raw_parts<'a, T>(data: *const T, len: usize) -> &'a [T]
    Expand description

    Forms a slice from a pointer and a length.

    │ │ │ │ +

    Function alloc::slice::from_raw_parts

    1.0.0 (const: 1.64.0) · source · 
    pub const unsafe fn from_raw_parts<'a, T>(data: *const T, len: usize) -> &'a [T]
    Expand description

    Forms a slice from a pointer and a length.

    │ │ │ │

    The len argument is the number of elements, not the number of bytes.

    │ │ │ │

    §Safety

    │ │ │ │

    Behavior is undefined if any of the following conditions are violated:

    │ │ │ │
      │ │ │ │
    • │ │ │ │ -

      data must be valid for reads for len * mem::size_of::<T>() many bytes, │ │ │ │ +

      data must be valid for reads for len * mem::size_of::<T>() many bytes, │ │ │ │ and it must be properly aligned. This means in particular:

      │ │ │ │
        │ │ │ │
      • The entire memory range of this slice must be contained within a single allocated object! │ │ │ │ Slices can never span across multiple allocated objects. See below │ │ │ │ for an example incorrectly not taking this into account.
        • │ │ │ │
      • data must be non-null and aligned even for zero-length slices. One │ │ │ │ reason for this is that enum layout optimizations may rely on references │ │ │ │ (including slices of any length) being aligned and non-null to distinguish │ │ │ │ them from other data. You can obtain a pointer that is usable as data │ │ │ │ -for zero-length slices using NonNull::dangling().
        • │ │ │ │ +for zero-length slices using NonNull::dangling(). │ │ │ │
      │ │ │ │
      • │ │ │ │
    • │ │ │ │

      data must point to len consecutive properly initialized values of type T.

      │ │ │ │
      • │ │ │ │
    • │ │ │ │

      The memory referenced by the returned slice must not be mutated for the duration │ │ │ │ of lifetime 'a, except inside an UnsafeCell.

      │ │ │ │
      • │ │ │ │
    • │ │ │ │

      The total size len * mem::size_of::<T>() of the slice must be no larger than isize::MAX, │ │ │ │ and adding that size to data must not “wrap around” the address space. │ │ │ │ -See the safety documentation of pointer::offset.

      │ │ │ │ +See the safety documentation of pointer::offset.

      │ │ │ │
      • │ │ │ │
    │ │ │ │

    §Caveat

    │ │ │ │

    The lifetime for the returned slice is inferred from its usage. To │ │ │ │ prevent accidental misuse, it’s suggested to tie the lifetime to whichever │ │ │ │ source lifetime is safe in the context, such as by providing a helper │ │ │ │ function taking the lifetime of a host value for the slice, or by explicit │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_raw_parts_mut.html │ │ │ │ @@ -1,34 +1,34 @@ │ │ │ │ from_raw_parts_mut in alloc::slice - Rust

    │ │ │ │ -

    Function alloc::slice::from_raw_parts_mut

    1.0.0 (const: unstable) · source · 
    pub unsafe fn from_raw_parts_mut<'a, T>(data: *mut T, len: usize) -> &'a mut [T]
    Expand description

    Performs the same functionality as from_raw_parts, except that a │ │ │ │ +

    Function alloc::slice::from_raw_parts_mut

    1.0.0 (const: unstable) · source · 
    pub unsafe fn from_raw_parts_mut<'a, T>(data: *mut T, len: usize) -> &'a mut [T]
    Expand description

    Performs the same functionality as from_raw_parts, except that a │ │ │ │ mutable slice is returned.

    │ │ │ │

    §Safety

    │ │ │ │

    Behavior is undefined if any of the following conditions are violated:

    │ │ │ │
      │ │ │ │
    • │ │ │ │ -

      data must be valid for both reads and writes for len * mem::size_of::<T>() many bytes, │ │ │ │ +

      data must be valid for both reads and writes for len * mem::size_of::<T>() many bytes, │ │ │ │ and it must be properly aligned. This means in particular:

      │ │ │ │
        │ │ │ │
      • The entire memory range of this slice must be contained within a single allocated object! │ │ │ │ Slices can never span across multiple allocated objects.
        • │ │ │ │
      • data must be non-null and aligned even for zero-length slices. One │ │ │ │ reason for this is that enum layout optimizations may rely on references │ │ │ │ (including slices of any length) being aligned and non-null to distinguish │ │ │ │ them from other data. You can obtain a pointer that is usable as data │ │ │ │ -for zero-length slices using NonNull::dangling().
        • │ │ │ │ +for zero-length slices using NonNull::dangling(). │ │ │ │
      │ │ │ │
      • │ │ │ │
    • │ │ │ │

      data must point to len consecutive properly initialized values of type T.

      │ │ │ │
      • │ │ │ │
    • │ │ │ │

      The memory referenced by the returned slice must not be accessed through any other pointer │ │ │ │ (not derived from the return value) for the duration of lifetime 'a. │ │ │ │ Both read and write accesses are forbidden.

      │ │ │ │
      • │ │ │ │
    • │ │ │ │

      The total size len * mem::size_of::<T>() of the slice must be no larger than isize::MAX, │ │ │ │ and adding that size to data must not “wrap around” the address space. │ │ │ │ -See the safety documentation of pointer::offset.

      │ │ │ │ +See the safety documentation of pointer::offset.

      │ │ │ │
      • │ │ │ │
    │ │ │ │
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.from_ref.html │ │ │ │ @@ -1,3 +1,3 @@ │ │ │ │ from_ref in alloc::slice - Rust
    │ │ │ │ -

    Function alloc::slice::from_ref

    1.28.0 (const: 1.63.0) · source · 
    pub const fn from_ref<T>(s: &T) -> &[T]
    Expand description

    Converts a reference to T into a slice of length 1 (without copying).

    │ │ │ │ +

    Function alloc::slice::from_ref

    1.28.0 (const: 1.63.0) · source · 
    pub const fn from_ref<T>(s: &T) -> &[T]
    Expand description

    Converts a reference to T into a slice of length 1 (without copying).

    │ │ │ │
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.range.html │ │ │ │ @@ -1,29 +1,29 @@ │ │ │ │ range in alloc::slice - Rust
    │ │ │ │ -

    Function alloc::slice::range

    source · 
    pub fn range<R>(range: R, bounds: RangeTo<usize>) -> Range<usize>
    where
│ │ │ │ -    R: RangeBounds<usize>,
    🔬This is a nightly-only experimental API. (slice_range #76393)
    Expand description

    Performs bounds-checking of a range.

    │ │ │ │ -

    This method is similar to Index::index for slices, but it returns a │ │ │ │ -Range equivalent to range. You can use this method to turn any range │ │ │ │ +

    Function alloc::slice::range

    source · 
    pub fn range<R>(range: R, bounds: RangeTo<usize>) -> Range<usize>
    where
│ │ │ │ +    R: RangeBounds<usize>,
    🔬This is a nightly-only experimental API. (slice_range #76393)
    Expand description

    Performs bounds-checking of a range.

    │ │ │ │ +

    This method is similar to Index::index for slices, but it returns a │ │ │ │ +Range equivalent to range. You can use this method to turn any range │ │ │ │ into start and end values.

    │ │ │ │

    bounds is the range of the slice to use for bounds-checking. It should │ │ │ │ -be a RangeTo range that ends at the length of the slice.

    │ │ │ │ -

    The returned Range is safe to pass to slice::get_unchecked and │ │ │ │ -slice::get_unchecked_mut for slices with the given range.

    │ │ │ │ +be a RangeTo range that ends at the length of the slice.

    │ │ │ │ +

    The returned Range is safe to pass to slice::get_unchecked and │ │ │ │ +slice::get_unchecked_mut for slices with the given range.

    │ │ │ │

    §Panics

    │ │ │ │

    Panics if range would be out of bounds.

    │ │ │ │

    §Examples

    │ │ │ │ 
    #![feature(slice_range)]
│ │ │ │  
│ │ │ │  use std::slice;
│ │ │ │  
│ │ │ │  let v = [10, 40, 30];
│ │ │ │  assert_eq!(1..2, slice::range(1..2, ..v.len()));
│ │ │ │  assert_eq!(0..2, slice::range(..2, ..v.len()));
│ │ │ │  assert_eq!(1..3, slice::range(1.., ..v.len()));
    Run
    │ │ │ │ -

    Panics when Index::index would panic:

    │ │ │ │ +

    Panics when Index::index would panic:

    │ │ │ │ │ │ │ │
    ⓘ
    #![feature(slice_range)]
│ │ │ │  
│ │ │ │  use std::slice;
│ │ │ │  
│ │ │ │  let _ = slice::range(2..1, ..3);
    Run
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/fn.try_range.html │ │ │ │ @@ -1,21 +1,21 @@ │ │ │ │ try_range in alloc::slice - Rust
    │ │ │ │ -

    Function alloc::slice::try_range

    source · 
    pub fn try_range<R>(range: R, bounds: RangeTo<usize>) -> Option<Range<usize>>
    where
│ │ │ │ -    R: RangeBounds<usize>,
    🔬This is a nightly-only experimental API. (slice_range #76393)
    Expand description

    Performs bounds-checking of a range without panicking.

    │ │ │ │ -

    This is a version of range that returns None instead of panicking.

    │ │ │ │ +

    Function alloc::slice::try_range

    source · 
    pub fn try_range<R>(range: R, bounds: RangeTo<usize>) -> Option<Range<usize>>
    where
│ │ │ │ +    R: RangeBounds<usize>,
    🔬This is a nightly-only experimental API. (slice_range #76393)
    Expand description

    Performs bounds-checking of a range without panicking.

    │ │ │ │ +

    This is a version of range that returns None instead of panicking.

    │ │ │ │

    §Examples

    │ │ │ │ 
    #![feature(slice_range)]
│ │ │ │  
│ │ │ │  use std::slice;
│ │ │ │  
│ │ │ │  let v = [10, 40, 30];
│ │ │ │  assert_eq!(Some(1..2), slice::try_range(1..2, ..v.len()));
│ │ │ │  assert_eq!(Some(0..2), slice::try_range(..2, ..v.len()));
│ │ │ │  assert_eq!(Some(1..3), slice::try_range(1.., ..v.len()));
    Run
    │ │ │ │ -

    Returns None when Index::index would panic:

    │ │ │ │ +

    Returns None when Index::index would panic:

    │ │ │ │ │ │ │ │ 
    #![feature(slice_range)]
│ │ │ │  
│ │ │ │  use std::slice;
│ │ │ │  
│ │ │ │  assert_eq!(None, slice::try_range(2..1, ..3));
│ │ │ │  assert_eq!(None, slice::try_range(1..4, ..3));
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/index.html
│ │ │ │ @@ -1,10 +1,10 @@
│ │ │ │  alloc::slice - Rust
    
│ │ │ │      
    Module alloc::slice
    1.0.0 · source · 
    Expand description
    Utilities for the slice primitive type.
    
│ │ │ │ -
    See also the slice primitive type.
    
│ │ │ │ +
    See also the slice primitive type.
    
│ │ │ │  
    Most of the structs in this module are iterator types which can only be created
│ │ │ │  using a certain function. For example, slice.iter() yields an Iter.
    
│ │ │ │  
    A few functions are provided to create a slice from a value reference
│ │ │ │  or from a raw pointer.
    
│ │ │ │  
    Structs§
    • ChunkBy
      An iterator over slice in (non-overlapping) chunks separated by a predicate.
    • ChunkByMut
      An iterator over slice in (non-overlapping) mutable chunks separated
│ │ │ │  by a predicate.
    • Chunks
      An iterator over a slice in (non-overlapping) chunks (chunk_size elements at a
│ │ │ │  time), starting at the beginning of the slice.
    • ChunksExact
      An iterator over a slice in (non-overlapping) chunks (chunk_size elements at a
│ │ │ │ @@ -27,9 +27,9 @@
│ │ │ │  by elements that match pred. Unlike SplitMut, it contains the matched
│ │ │ │  parts in the ends of the subslices.
    • SplitMut
      An iterator over the mutable subslices of the vector which are separated
│ │ │ │  by elements that match pred.
    • SplitN
      An iterator over subslices separated by elements that match a predicate
│ │ │ │  function, limited to a given number of splits.
    • SplitNMut
      An iterator over subslices separated by elements that match a predicate
│ │ │ │  function, limited to a given number of splits.
    • Windows
      An iterator over overlapping subslices of length size.
    • ArrayChunksExperimental
      An iterator over a slice in (non-overlapping) chunks (N elements at a
│ │ │ │  time), starting at the beginning of the slice.
    • ArrayChunksMutExperimental
      An iterator over a slice in (non-overlapping) mutable chunks (N elements
│ │ │ │  at a time), starting at the beginning of the slice.
    • ArrayWindowsExperimental
      A windowed iterator over a slice in overlapping chunks (N elements at a
│ │ │ │ -time), starting at the beginning of the slice
    Traits§
    Functions§
    • from_mut
      Converts a reference to T into a slice of length 1 (without copying).
    • from_raw_parts⚠
      Forms a slice from a pointer and a length.
    • from_raw_parts_mut⚠
      Performs the same functionality as from_raw_parts, except that a
│ │ │ │ +time), starting at the beginning of the slice
    Traits§
    Functions§
    • from_mut
      Converts a reference to T into a slice of length 1 (without copying).
    • from_raw_parts⚠
      Forms a slice from a pointer and a length.
    • from_raw_parts_mut⚠
      Performs the same functionality as from_raw_parts, except that a
│ │ │ │  mutable slice is returned.
    • from_ref
      Converts a reference to T into a slice of length 1 (without copying).
    • from_mut_ptr_range⚠Experimental
      Forms a mutable slice from a pointer range.
    • from_ptr_range⚠Experimental
      Forms a slice from a pointer range.
    • rangeExperimental
      Performs bounds-checking of a range.
    • try_rangeExperimental
      Performs bounds-checking of a range without panicking.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ArrayChunks.html
│ │ │ │ @@ -1,231 +1,231 @@
│ │ │ │  ArrayChunks in alloc::slice - Rust
    
│ │ │ │ -    
    Struct alloc::slice::ArrayChunks
    source · 
    pub struct ArrayChunks<'a, T, const N: usize>
    where
│ │ │ │ +    
    Struct alloc::slice::ArrayChunks
    source · 
    pub struct ArrayChunks<'a, T, const N: usize>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    🔬This is a nightly-only experimental API. (array_chunks #74985)
    Expand description
    An iterator over a slice in (non-overlapping) chunks (N elements at a
│ │ │ │  time), starting at the beginning of the slice.
    
│ │ │ │  
    When the slice len is not evenly divided by the chunk size, the last
│ │ │ │  up to N-1 elements will be omitted but can be retrieved from
│ │ │ │  the remainder function from the iterator.
    
│ │ │ │ -
    This struct is created by the array_chunks method on slices.
    
│ │ │ │ +
    This struct is created by the array_chunks method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    #![feature(array_chunks)]
│ │ │ │  
│ │ │ │  let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let iter = slice.array_chunks::<2>();
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, T, const N: usize> ArrayChunks<'a, T, N>
    source
    pub fn remainder(&self) -> &'a [T]
    🔬This is a nightly-only experimental API. (array_chunks #74985)
    Returns the remainder of the original slice that is not going to be
│ │ │ │ +
    Implementations§
    source§
    impl<'a, T, const N: usize> ArrayChunks<'a, T, N>
    source
    pub fn remainder(&self) -> &'a [T]
    🔬This is a nightly-only experimental API. (array_chunks #74985)
    Returns the remainder of the original slice that is not going to be
│ │ │ │  returned by the iterator. The returned slice has at most N-1
│ │ │ │  elements.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<T, const N: usize> Clone for ArrayChunks<'_, T, N>
    source§
    fn clone(&self) -> ArrayChunks<'_, T, N> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T, const N: usize> Debug for ArrayChunks<'a, T, N>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunks<'a, T, N>
    source§
    fn next_back(&mut self) -> Option<&'a [T; N]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<T, const N: usize> Clone for ArrayChunks<'_, T, N>
    source§
    fn clone(&self) -> ArrayChunks<'_, T, N> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T, const N: usize> Debug for ArrayChunks<'a, T, N>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunks<'a, T, N>
    source§
    fn next_back(&mut self) -> Option<&'a [T; N]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │      &mut self,
│ │ │ │ -    n: usize
│ │ │ │ -) -> Option<<ArrayChunks<'a, T, N> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T, const N: usize> ExactSizeIterator for ArrayChunks<'_, T, N>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T, const N: usize> Iterator for ArrayChunks<'a, T, N>
    §
    type Item = &'a [T; N]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T; N]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<ArrayChunks<'a, T, N> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ArrayChunks<'a, T, N> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    n: usize
│ │ │ │ +) -> Option<<ArrayChunks<'a, T, N> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T, const N: usize> ExactSizeIterator for ArrayChunks<'_, T, N>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T, const N: usize> Iterator for ArrayChunks<'a, T, N>
    §
    type Item = &'a [T; N]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T; N]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<ArrayChunks<'a, T, N> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ArrayChunks<'a, T, N> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T, const N: usize> FusedIterator for ArrayChunks<'_, T, N>

    source§

    impl<T, const N: usize> TrustedLen for ArrayChunks<'_, T, N>

    Auto Trait Implementations§

    §

    impl<'a, T, const N: usize> Freeze for ArrayChunks<'a, T, N>

    §

    impl<'a, T, const N: usize> RefUnwindSafe for ArrayChunks<'a, T, N>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, const N: usize> Send for ArrayChunks<'a, T, N>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T, const N: usize> Sync for ArrayChunks<'a, T, N>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T, const N: usize> Unpin for ArrayChunks<'a, T, N>

    §

    impl<'a, T, const N: usize> UnwindSafe for ArrayChunks<'a, T, N>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T, const N: usize> FusedIterator for ArrayChunks<'_, T, N>

    source§

    impl<T, const N: usize> TrustedLen for ArrayChunks<'_, T, N>

    Auto Trait Implementations§

    §

    impl<'a, T, const N: usize> Freeze for ArrayChunks<'a, T, N>

    §

    impl<'a, T, const N: usize> RefUnwindSafe for ArrayChunks<'a, T, N>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, const N: usize> Send for ArrayChunks<'a, T, N>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T, const N: usize> Sync for ArrayChunks<'a, T, N>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T, const N: usize> Unpin for ArrayChunks<'a, T, N>

    §

    impl<'a, T, const N: usize> UnwindSafe for ArrayChunks<'a, T, N>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ArrayChunksMut.html │ │ │ │ @@ -1,231 +1,231 @@ │ │ │ │ ArrayChunksMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::ArrayChunksMut

    source · 
    pub struct ArrayChunksMut<'a, T, const N: usize>
    where
│ │ │ │ +    
    Struct alloc::slice::ArrayChunksMut
    source · 
    pub struct ArrayChunksMut<'a, T, const N: usize>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    🔬This is a nightly-only experimental API. (array_chunks #74985)
    Expand description
    An iterator over a slice in (non-overlapping) mutable chunks (N elements
│ │ │ │  at a time), starting at the beginning of the slice.
    
│ │ │ │  
    When the slice len is not evenly divided by the chunk size, the last
│ │ │ │  up to N-1 elements will be omitted but can be retrieved from
│ │ │ │  the into_remainder function from the iterator.
    
│ │ │ │ -
    This struct is created by the array_chunks_mut method on slices.
    
│ │ │ │ +
    This struct is created by the array_chunks_mut method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    #![feature(array_chunks)]
│ │ │ │  
│ │ │ │  let mut slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let iter = slice.array_chunks_mut::<2>();
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, T, const N: usize> ArrayChunksMut<'a, T, N>
    source
    pub fn into_remainder(self) -> &'a mut [T]
    🔬This is a nightly-only experimental API. (array_chunks #74985)
    Returns the remainder of the original slice that is not going to be
│ │ │ │ +
    Implementations§
    source§
    impl<'a, T, const N: usize> ArrayChunksMut<'a, T, N>
    source
    pub fn into_remainder(self) -> &'a mut [T]
    🔬This is a nightly-only experimental API. (array_chunks #74985)
    Returns the remainder of the original slice that is not going to be
│ │ │ │  returned by the iterator. The returned slice has at most N-1
│ │ │ │  elements.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, T, const N: usize> Debug for ArrayChunksMut<'a, T, N>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunksMut<'a, T, N>
    source§
    fn next_back(&mut self) -> Option<&'a mut [T; N]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, T, const N: usize> Debug for ArrayChunksMut<'a, T, N>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunksMut<'a, T, N>
    source§
    fn next_back(&mut self) -> Option<&'a mut [T; N]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │      &mut self,
│ │ │ │ -    n: usize
│ │ │ │ -) -> Option<<ArrayChunksMut<'a, T, N> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T, const N: usize> ExactSizeIterator for ArrayChunksMut<'_, T, N>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T, const N: usize> Iterator for ArrayChunksMut<'a, T, N>
    §
    type Item = &'a mut [T; N]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut [T; N]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(
│ │ │ │ +    n: usize
│ │ │ │ +) -> Option<<ArrayChunksMut<'a, T, N> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T, const N: usize> ExactSizeIterator for ArrayChunksMut<'_, T, N>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T, const N: usize> Iterator for ArrayChunksMut<'a, T, N>
    §
    type Item = &'a mut [T; N]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut [T; N]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(
│ │ │ │      &mut self,
│ │ │ │ -    n: usize
│ │ │ │ -) -> Option<<ArrayChunksMut<'a, T, N> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ArrayChunksMut<'a, T, N> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    n: usize
│ │ │ │ +) -> Option<<ArrayChunksMut<'a, T, N> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ArrayChunksMut<'a, T, N> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T, const N: usize> FusedIterator for ArrayChunksMut<'_, T, N>

    source§

    impl<T, const N: usize> TrustedLen for ArrayChunksMut<'_, T, N>

    Auto Trait Implementations§

    §

    impl<'a, T, const N: usize> Freeze for ArrayChunksMut<'a, T, N>

    §

    impl<'a, T, const N: usize> RefUnwindSafe for ArrayChunksMut<'a, T, N>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, const N: usize> Send for ArrayChunksMut<'a, T, N>
    where │ │ │ │ - T: Send,

    §

    impl<'a, T, const N: usize> Sync for ArrayChunksMut<'a, T, N>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T, const N: usize> Unpin for ArrayChunksMut<'a, T, N>

    §

    impl<'a, T, const N: usize> !UnwindSafe for ArrayChunksMut<'a, T, N>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T, const N: usize> FusedIterator for ArrayChunksMut<'_, T, N>

    source§

    impl<T, const N: usize> TrustedLen for ArrayChunksMut<'_, T, N>

    Auto Trait Implementations§

    §

    impl<'a, T, const N: usize> Freeze for ArrayChunksMut<'a, T, N>

    §

    impl<'a, T, const N: usize> RefUnwindSafe for ArrayChunksMut<'a, T, N>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, const N: usize> Send for ArrayChunksMut<'a, T, N>
    where │ │ │ │ + T: Send,

    §

    impl<'a, T, const N: usize> Sync for ArrayChunksMut<'a, T, N>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T, const N: usize> Unpin for ArrayChunksMut<'a, T, N>

    §

    impl<'a, T, const N: usize> !UnwindSafe for ArrayChunksMut<'a, T, N>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ArrayWindows.html │ │ │ │ @@ -1,224 +1,224 @@ │ │ │ │ ArrayWindows in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::ArrayWindows

    source · 
    pub struct ArrayWindows<'a, T, const N: usize>
    where
│ │ │ │ +    
    Struct alloc::slice::ArrayWindows
    source · 
    pub struct ArrayWindows<'a, T, const N: usize>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    🔬This is a nightly-only experimental API. (array_windows #75027)
    Expand description
    A windowed iterator over a slice in overlapping chunks (N elements at a
│ │ │ │  time), starting at the beginning of the slice
    
│ │ │ │ -
    This struct is created by the array_windows method on slices.
    
│ │ │ │ +
    This struct is created by the array_windows method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    #![feature(array_windows)]
│ │ │ │  
│ │ │ │  let slice = [0, 1, 2, 3];
│ │ │ │  let iter = slice.array_windows::<2>();
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, T, const N: usize> Clone for ArrayWindows<'a, T, N>
    where
│ │ │ │ -    T: Clone + 'a,
    source§
    fn clone(&self) -> ArrayWindows<'a, T, N> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T, const N: usize> Debug for ArrayWindows<'a, T, N>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T, const N: usize> DoubleEndedIterator for ArrayWindows<'a, T, N>
    source§
    fn next_back(&mut self) -> Option<&'a [T; N]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<&'a [T; N]>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T, const N: usize> ExactSizeIterator for ArrayWindows<'_, T, N>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T, const N: usize> Iterator for ArrayWindows<'a, T, N>
    §
    type Item = &'a [T; N]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<<ArrayWindows<'a, T, N> as Iterator>::Item>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, T, const N: usize> Clone for ArrayWindows<'a, T, N>
    where
│ │ │ │ +    T: Clone + 'a,
    source§
    fn clone(&self) -> ArrayWindows<'a, T, N> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T, const N: usize> Debug for ArrayWindows<'a, T, N>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T, const N: usize> DoubleEndedIterator for ArrayWindows<'a, T, N>
    source§
    fn next_back(&mut self) -> Option<&'a [T; N]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<&'a [T; N]>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T, const N: usize> ExactSizeIterator for ArrayWindows<'_, T, N>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T, const N: usize> Iterator for ArrayWindows<'a, T, N>
    §
    type Item = &'a [T; N]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<<ArrayWindows<'a, T, N> as Iterator>::Item>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(
│ │ │ │      &mut self,
│ │ │ │ -    n: usize
│ │ │ │ -) -> Option<<ArrayWindows<'a, T, N> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ArrayWindows<'a, T, N> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    n: usize
│ │ │ │ +) -> Option<<ArrayWindows<'a, T, N> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ArrayWindows<'a, T, N> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<'a, T, const N: usize> Copy for ArrayWindows<'a, T, N>
    where │ │ │ │ - T: Copy + 'a,

    Auto Trait Implementations§

    §

    impl<'a, T, const N: usize> Freeze for ArrayWindows<'a, T, N>

    §

    impl<'a, T, const N: usize> RefUnwindSafe for ArrayWindows<'a, T, N>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, const N: usize> !Send for ArrayWindows<'a, T, N>

    §

    impl<'a, T, const N: usize> !Sync for ArrayWindows<'a, T, N>

    §

    impl<'a, T, const N: usize> Unpin for ArrayWindows<'a, T, N>

    §

    impl<'a, T, const N: usize> UnwindSafe for ArrayWindows<'a, T, N>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<'a, T, const N: usize> Copy for ArrayWindows<'a, T, N>
    where │ │ │ │ + T: Copy + 'a,

    Auto Trait Implementations§

    §

    impl<'a, T, const N: usize> Freeze for ArrayWindows<'a, T, N>

    §

    impl<'a, T, const N: usize> RefUnwindSafe for ArrayWindows<'a, T, N>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, const N: usize> !Send for ArrayWindows<'a, T, N>

    §

    impl<'a, T, const N: usize> !Sync for ArrayWindows<'a, T, N>

    §

    impl<'a, T, const N: usize> Unpin for ArrayWindows<'a, T, N>

    §

    impl<'a, T, const N: usize> UnwindSafe for ArrayWindows<'a, T, N>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunkBy.html │ │ │ │ @@ -1,224 +1,224 @@ │ │ │ │ ChunkBy in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::ChunkBy

    1.77.0 · source · 
    pub struct ChunkBy<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::ChunkBy
    1.77.0 · source · 
    pub struct ChunkBy<'a, T, P>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    An iterator over slice in (non-overlapping) chunks separated by a predicate.
    
│ │ │ │ -
    This struct is created by the chunk_by method on slices.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, T, P> Debug for ChunkBy<'a, T, P>
    where
│ │ │ │ -    T: 'a + Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T, P> DoubleEndedIterator for ChunkBy<'a, T, P>
    where
│ │ │ │ +
    This struct is created by the chunk_by method on slices.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, T, P> Debug for ChunkBy<'a, T, P>
    where
│ │ │ │ +    T: 'a + Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T, P> DoubleEndedIterator for ChunkBy<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T, &T) -> bool,
    source§
    fn next_back(&mut self) -> Option<<ChunkBy<'a, T, P> as Iterator>::Item>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, T, P> Iterator for ChunkBy<'a, T, P>
    where
│ │ │ │ +    P: FnMut(&T, &T) -> bool,
    source§
    fn next_back(&mut self) -> Option<<ChunkBy<'a, T, P> as Iterator>::Item>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, T, P> Iterator for ChunkBy<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T, &T) -> bool,
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<<ChunkBy<'a, T, P> as Iterator>::Item>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<<ChunkBy<'a, T, P> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    P: FnMut(&T, &T) -> bool,
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<<ChunkBy<'a, T, P> as Iterator>::Item>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<<ChunkBy<'a, T, P> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<'a, T, P> FusedIterator for ChunkBy<'a, T, P>
    where │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<'a, T, P> FusedIterator for ChunkBy<'a, T, P>
    where │ │ │ │ T: 'a, │ │ │ │ - P: FnMut(&T, &T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for ChunkBy<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for ChunkBy<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for ChunkBy<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Sync for ChunkBy<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for ChunkBy<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for ChunkBy<'a, T, P>
    where │ │ │ │ - P: UnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ + P: FnMut(&T, &T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for ChunkBy<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for ChunkBy<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for ChunkBy<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Sync for ChunkBy<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for ChunkBy<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for ChunkBy<'a, T, P>
    where │ │ │ │ + P: UnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunkByMut.html │ │ │ │ @@ -1,223 +1,223 @@ │ │ │ │ ChunkByMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::ChunkByMut

    1.77.0 · source · 
    pub struct ChunkByMut<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::ChunkByMut
    1.77.0 · source · 
    pub struct ChunkByMut<'a, T, P>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    An iterator over slice in (non-overlapping) mutable chunks separated
│ │ │ │  by a predicate.
    
│ │ │ │ -
    This struct is created by the chunk_by_mut method on slices.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, T, P> Debug for ChunkByMut<'a, T, P>
    where
│ │ │ │ -    T: 'a + Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T, P> DoubleEndedIterator for ChunkByMut<'a, T, P>
    where
│ │ │ │ +
    This struct is created by the chunk_by_mut method on slices.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, T, P> Debug for ChunkByMut<'a, T, P>
    where
│ │ │ │ +    T: 'a + Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T, P> DoubleEndedIterator for ChunkByMut<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T, &T) -> bool,
    source§
    fn next_back(&mut self) -> Option<<ChunkByMut<'a, T, P> as Iterator>::Item>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, T, P> Iterator for ChunkByMut<'a, T, P>
    where
│ │ │ │ +    P: FnMut(&T, &T) -> bool,
    source§
    fn next_back(&mut self) -> Option<<ChunkByMut<'a, T, P> as Iterator>::Item>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, T, P> Iterator for ChunkByMut<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T, &T) -> bool,
    §
    type Item = &'a mut [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<<ChunkByMut<'a, T, P> as Iterator>::Item>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<<ChunkByMut<'a, T, P> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    P: FnMut(&T, &T) -> bool,
    §
    type Item = &'a mut [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<<ChunkByMut<'a, T, P> as Iterator>::Item>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<<ChunkByMut<'a, T, P> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<'a, T, P> FusedIterator for ChunkByMut<'a, T, P>
    where │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<'a, T, P> FusedIterator for ChunkByMut<'a, T, P>
    where │ │ │ │ T: 'a, │ │ │ │ - P: FnMut(&T, &T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for ChunkByMut<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for ChunkByMut<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for ChunkByMut<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Send,

    §

    impl<'a, T, P> Sync for ChunkByMut<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for ChunkByMut<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for ChunkByMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ + P: FnMut(&T, &T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for ChunkByMut<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for ChunkByMut<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for ChunkByMut<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Send,

    §

    impl<'a, T, P> Sync for ChunkByMut<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for ChunkByMut<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for ChunkByMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Chunks.html │ │ │ │ @@ -1,222 +1,222 @@ │ │ │ │ Chunks in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::Chunks

    1.0.0 · source · 
    pub struct Chunks<'a, T>
    where
│ │ │ │ +    
    Struct alloc::slice::Chunks
    1.0.0 · source · 
    pub struct Chunks<'a, T>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    An iterator over a slice in (non-overlapping) chunks (chunk_size elements at a
│ │ │ │  time), starting at the beginning of the slice.
    
│ │ │ │  
    When the slice len is not evenly divided by the chunk size, the last slice
│ │ │ │  of the iteration will be the remainder.
    
│ │ │ │ -
    This struct is created by the chunks method on slices.
    
│ │ │ │ +
    This struct is created by the chunks method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let iter = slice.chunks(2);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<T> Clone for Chunks<'_, T>
    source§
    fn clone(&self) -> Chunks<'_, T> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T> Debug for Chunks<'a, T>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for Chunks<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<<Chunks<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for Chunks<'_, T>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for Chunks<'a, T>
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<Chunks<'a, T> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<Chunks<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<T> Clone for Chunks<'_, T>
    source§
    fn clone(&self) -> Chunks<'_, T> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T> Debug for Chunks<'a, T>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for Chunks<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<<Chunks<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for Chunks<'_, T>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for Chunks<'a, T>
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<Chunks<'a, T> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<Chunks<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Chunks<'_, T>

    source§

    impl<T> TrustedLen for Chunks<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Chunks<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Chunks<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for Chunks<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Sync for Chunks<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for Chunks<'a, T>

    §

    impl<'a, T> UnwindSafe for Chunks<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Chunks<'_, T>

    source§

    impl<T> TrustedLen for Chunks<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Chunks<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Chunks<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for Chunks<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Sync for Chunks<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for Chunks<'a, T>

    §

    impl<'a, T> UnwindSafe for Chunks<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunksExact.html │ │ │ │ @@ -1,239 +1,239 @@ │ │ │ │ ChunksExact in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::ChunksExact

    1.31.0 · source · 
    pub struct ChunksExact<'a, T>
    where
│ │ │ │ +    
    Struct alloc::slice::ChunksExact
    1.31.0 · source · 
    pub struct ChunksExact<'a, T>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    An iterator over a slice in (non-overlapping) chunks (chunk_size elements at a
│ │ │ │  time), starting at the beginning of the slice.
    
│ │ │ │  
    When the slice len is not evenly divided by the chunk size, the last
│ │ │ │  up to chunk_size-1 elements will be omitted but can be retrieved from
│ │ │ │  the remainder function from the iterator.
    
│ │ │ │ -
    This struct is created by the chunks_exact method on slices.
    
│ │ │ │ +
    This struct is created by the chunks_exact method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let iter = slice.chunks_exact(2);
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, T> ChunksExact<'a, T>
    source
    pub fn remainder(&self) -> &'a [T]
    Returns the remainder of the original slice that is not going to be
│ │ │ │ +
    Implementations§
    source§
    impl<'a, T> ChunksExact<'a, T>
    source
    pub fn remainder(&self) -> &'a [T]
    Returns the remainder of the original slice that is not going to be
│ │ │ │  returned by the iterator. The returned slice has at most chunk_size-1
│ │ │ │  elements.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let mut iter = slice.chunks_exact(2);
│ │ │ │  assert_eq!(iter.remainder(), &['m'][..]);
│ │ │ │  assert_eq!(iter.next(), Some(&['l', 'o'][..]));
│ │ │ │  assert_eq!(iter.remainder(), &['m'][..]);
│ │ │ │  assert_eq!(iter.next(), Some(&['r', 'e'][..]));
│ │ │ │  assert_eq!(iter.remainder(), &['m'][..]);
│ │ │ │  assert_eq!(iter.next(), None);
│ │ │ │  assert_eq!(iter.remainder(), &['m'][..]);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<T> Clone for ChunksExact<'_, T>
    source§
    fn clone(&self) -> ChunksExact<'_, T> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T> Debug for ChunksExact<'a, T>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for ChunksExact<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<T> Clone for ChunksExact<'_, T>
    source§
    fn clone(&self) -> ChunksExact<'_, T> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T> Debug for ChunksExact<'a, T>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for ChunksExact<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │      &mut self,
│ │ │ │ -    n: usize
│ │ │ │ -) -> Option<<ChunksExact<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for ChunksExact<'_, T>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T> Iterator for ChunksExact<'a, T>
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<ChunksExact<'a, T> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ChunksExact<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    n: usize
│ │ │ │ +) -> Option<<ChunksExact<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for ChunksExact<'_, T>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T> Iterator for ChunksExact<'a, T>
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<ChunksExact<'a, T> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ChunksExact<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T> FusedIterator for ChunksExact<'_, T>

    source§

    impl<T> TrustedLen for ChunksExact<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for ChunksExact<'a, T>

    §

    impl<'a, T> RefUnwindSafe for ChunksExact<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for ChunksExact<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Sync for ChunksExact<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for ChunksExact<'a, T>

    §

    impl<'a, T> UnwindSafe for ChunksExact<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T> FusedIterator for ChunksExact<'_, T>

    source§

    impl<T> TrustedLen for ChunksExact<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for ChunksExact<'a, T>

    §

    impl<'a, T> RefUnwindSafe for ChunksExact<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for ChunksExact<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Sync for ChunksExact<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for ChunksExact<'a, T>

    §

    impl<'a, T> UnwindSafe for ChunksExact<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunksExactMut.html │ │ │ │ @@ -1,226 +1,226 @@ │ │ │ │ ChunksExactMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::ChunksExactMut

    1.31.0 · source · 
    pub struct ChunksExactMut<'a, T>
    where
│ │ │ │ +    
    Struct alloc::slice::ChunksExactMut
    1.31.0 · source · 
    pub struct ChunksExactMut<'a, T>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    An iterator over a slice in (non-overlapping) mutable chunks (chunk_size
│ │ │ │  elements at a time), starting at the beginning of the slice.
    
│ │ │ │  
    When the slice len is not evenly divided by the chunk size, the last up to
│ │ │ │  chunk_size-1 elements will be omitted but can be retrieved from the
│ │ │ │  into_remainder function from the iterator.
    
│ │ │ │ -
    This struct is created by the chunks_exact_mut method on slices.
    
│ │ │ │ +
    This struct is created by the chunks_exact_mut method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let mut slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let iter = slice.chunks_exact_mut(2);
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, T> ChunksExactMut<'a, T>
    source
    pub fn into_remainder(self) -> &'a mut [T]
    Returns the remainder of the original slice that is not going to be
│ │ │ │ +
    Implementations§
    source§
    impl<'a, T> ChunksExactMut<'a, T>
    source
    pub fn into_remainder(self) -> &'a mut [T]
    Returns the remainder of the original slice that is not going to be
│ │ │ │  returned by the iterator. The returned slice has at most chunk_size-1
│ │ │ │  elements.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, T> Debug for ChunksExactMut<'a, T>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for ChunksExactMut<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a mut [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, T> Debug for ChunksExactMut<'a, T>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for ChunksExactMut<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a mut [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │      &mut self,
│ │ │ │ -    n: usize
│ │ │ │ -) -> Option<<ChunksExactMut<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for ChunksExactMut<'_, T>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T> Iterator for ChunksExactMut<'a, T>
    §
    type Item = &'a mut [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a mut [T]>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ChunksExactMut<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    n: usize
│ │ │ │ +) -> Option<<ChunksExactMut<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for ChunksExactMut<'_, T>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T> Iterator for ChunksExactMut<'a, T>
    §
    type Item = &'a mut [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a mut [T]>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ChunksExactMut<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T> FusedIterator for ChunksExactMut<'_, T>

    source§

    impl<T> Send for ChunksExactMut<'_, T>
    where │ │ │ │ - T: Send,

    source§

    impl<T> Sync for ChunksExactMut<'_, T>
    where │ │ │ │ - T: Sync,

    source§

    impl<T> TrustedLen for ChunksExactMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for ChunksExactMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for ChunksExactMut<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for ChunksExactMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for ChunksExactMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T> FusedIterator for ChunksExactMut<'_, T>

    source§

    impl<T> Send for ChunksExactMut<'_, T>
    where │ │ │ │ + T: Send,

    source§

    impl<T> Sync for ChunksExactMut<'_, T>
    where │ │ │ │ + T: Sync,

    source§

    impl<T> TrustedLen for ChunksExactMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for ChunksExactMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for ChunksExactMut<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for ChunksExactMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for ChunksExactMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.ChunksMut.html │ │ │ │ @@ -1,219 +1,219 @@ │ │ │ │ ChunksMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::ChunksMut

    1.0.0 · source · 
    pub struct ChunksMut<'a, T>
    where
│ │ │ │ +    
    Struct alloc::slice::ChunksMut
    1.0.0 · source · 
    pub struct ChunksMut<'a, T>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    An iterator over a slice in (non-overlapping) mutable chunks (chunk_size
│ │ │ │  elements at a time), starting at the beginning of the slice.
    
│ │ │ │  
    When the slice len is not evenly divided by the chunk size, the last slice
│ │ │ │  of the iteration will be the remainder.
    
│ │ │ │ -
    This struct is created by the chunks_mut method on slices.
    
│ │ │ │ +
    This struct is created by the chunks_mut method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let mut slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let iter = slice.chunks_mut(2);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, T> Debug for ChunksMut<'a, T>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a mut [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<<ChunksMut<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for ChunksMut<'_, T>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for ChunksMut<'a, T>
    §
    type Item = &'a mut [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a mut [T]>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ChunksMut<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, T> Debug for ChunksMut<'a, T>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a mut [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<<ChunksMut<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for ChunksMut<'_, T>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for ChunksMut<'a, T>
    §
    type Item = &'a mut [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a mut [T]>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<ChunksMut<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for ChunksMut<'_, T>

    source§

    impl<T> Send for ChunksMut<'_, T>
    where │ │ │ │ - T: Send,

    source§

    impl<T> Sync for ChunksMut<'_, T>
    where │ │ │ │ - T: Sync,

    source§

    impl<T> TrustedLen for ChunksMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for ChunksMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for ChunksMut<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for ChunksMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for ChunksMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for ChunksMut<'_, T>

    source§

    impl<T> Send for ChunksMut<'_, T>
    where │ │ │ │ + T: Send,

    source§

    impl<T> Sync for ChunksMut<'_, T>
    where │ │ │ │ + T: Sync,

    source§

    impl<T> TrustedLen for ChunksMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for ChunksMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for ChunksMut<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for ChunksMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for ChunksMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.EscapeAscii.html │ │ │ │ @@ -1,208 +1,208 @@ │ │ │ │ EscapeAscii in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::EscapeAscii

    1.60.0 · source · 
    pub struct EscapeAscii<'a> { /* private fields */ }
    Expand description

    An iterator over the escaped version of a byte slice.

    │ │ │ │ -

    This struct is created by the slice::escape_ascii method. See its │ │ │ │ +

    Struct alloc::slice::EscapeAscii

    1.60.0 · source · 
    pub struct EscapeAscii<'a> { /* private fields */ }
    Expand description

    An iterator over the escaped version of a byte slice.

    │ │ │ │ +

    This struct is created by the slice::escape_ascii method. See its │ │ │ │ documentation for more information.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<'a> Clone for EscapeAscii<'a>

    source§

    fn clone(&self) -> EscapeAscii<'a> ⓘ

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a> Debug for EscapeAscii<'a>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a> Display for EscapeAscii<'a>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a> DoubleEndedIterator for EscapeAscii<'a>

    source§

    fn next_back(&mut self) -> Option<u8>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a> Iterator for EscapeAscii<'a>

    §

    type Item = u8

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<u8>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
    where │ │ │ │ - Fold: FnMut(Acc, <EscapeAscii<'a> as Iterator>::Item) -> R, │ │ │ │ - R: Try<Output = Acc>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    source§

    fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
    where │ │ │ │ - Fold: FnMut(Acc, <EscapeAscii<'a> as Iterator>::Item) -> Acc,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    source§

    fn last(self) -> Option<u8>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ +

    Trait Implementations§

    source§

    impl<'a> Clone for EscapeAscii<'a>

    source§

    fn clone(&self) -> EscapeAscii<'a> ⓘ

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a> Debug for EscapeAscii<'a>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a> Display for EscapeAscii<'a>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a> DoubleEndedIterator for EscapeAscii<'a>

    source§

    fn next_back(&mut self) -> Option<u8>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a> Iterator for EscapeAscii<'a>

    §

    type Item = u8

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<u8>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
    where │ │ │ │ + Fold: FnMut(Acc, <EscapeAscii<'a> as Iterator>::Item) -> R, │ │ │ │ + R: Try<Output = Acc>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    source§

    fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
    where │ │ │ │ + Fold: FnMut(Acc, <EscapeAscii<'a> as Iterator>::Item) -> Acc,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    source§

    fn last(self) -> Option<u8>

    Consumes the iterator, returning the last element. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<'a> FusedIterator for EscapeAscii<'a>

    Auto Trait Implementations§

    §

    impl<'a> Freeze for EscapeAscii<'a>

    §

    impl<'a> RefUnwindSafe for EscapeAscii<'a>

    §

    impl<'a> Send for EscapeAscii<'a>

    §

    impl<'a> Sync for EscapeAscii<'a>

    §

    impl<'a> Unpin for EscapeAscii<'a>

    §

    impl<'a> UnwindSafe for EscapeAscii<'a>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<'a> FusedIterator for EscapeAscii<'a>

    Auto Trait Implementations§

    §

    impl<'a> Freeze for EscapeAscii<'a>

    §

    impl<'a> RefUnwindSafe for EscapeAscii<'a>

    §

    impl<'a> Send for EscapeAscii<'a>

    §

    impl<'a> Sync for EscapeAscii<'a>

    §

    impl<'a> Unpin for EscapeAscii<'a>

    §

    impl<'a> UnwindSafe for EscapeAscii<'a>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ - T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T> ToString for T
    where │ │ │ │ + T: Display + ?Sized,

    source§

    default fn to_string(&self) -> String

    Converts the given value to a String. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Iter.html │ │ │ │ @@ -1,22 +1,22 @@ │ │ │ │ Iter in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::Iter

    1.0.0 · source · 
    pub struct Iter<'a, T>
    where
│ │ │ │ +    
    Struct alloc::slice::Iter
    1.0.0 · source · 
    pub struct Iter<'a, T>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    Immutable slice iterator
    
│ │ │ │ -
    This struct is created by the iter method on slices.
    
│ │ │ │ +
    This struct is created by the iter method on slices.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    // First, we declare a type which has `iter` method to get the `Iter` struct (`&[usize]` here):
│ │ │ │  let slice = &[1, 2, 3];
│ │ │ │  
│ │ │ │  // Then, we iterate over it:
│ │ │ │  for element in slice.iter() {
│ │ │ │      println!("{element}");
│ │ │ │  }
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, T> Iter<'a, T>
    1.4.0 · source
    pub fn as_slice(&self) -> &'a [T]
    Views the underlying data as a subslice of the original data.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, T> Iter<'a, T>
    1.4.0 · source
    pub fn as_slice(&self) -> &'a [T]
    Views the underlying data as a subslice of the original data.
    
│ │ │ │  
    This has the same lifetime as the original slice, and so the
│ │ │ │  iterator can continue to be used while this exists.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    // First, we declare a type which has the `iter` method to get the `Iter`
│ │ │ │  // struct (`&[usize]` here):
│ │ │ │ @@ -27,222 +27,222 @@
│ │ │ │  // So if we print what `as_slice` method returns here, we have "[1, 2, 3]":
│ │ │ │  println!("{:?}", iter.as_slice());
│ │ │ │  
│ │ │ │  // Next, we move to the second element of the slice:
│ │ │ │  iter.next();
│ │ │ │  // Now `as_slice` returns "[2, 3]":
│ │ │ │  println!("{:?}", iter.as_slice());
    Run
    
│ │ │ │ -
    Trait Implementations§
    1.13.0 · source§
    impl<T> AsRef<[T]> for Iter<'_, T>
    source§
    fn as_ref(&self) -> &[T]
    Converts this type into a shared reference of the (usually inferred) input type.
    source§
    impl<T> Clone for Iter<'_, T>
    source§
    fn clone(&self) -> Iter<'_, T> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    1.9.0 · source§
    impl<T> Debug for Iter<'_, T>
    where
│ │ │ │ -    T: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    1.70.0 · source§
    impl<T> Default for Iter<'_, T>
    source§
    fn default() -> Iter<'_, T> ⓘ
    Creates an empty slice iterator.
    
│ │ │ │ +
    Trait Implementations§
    1.13.0 · source§
    impl<T> AsRef<[T]> for Iter<'_, T>
    source§
    fn as_ref(&self) -> &[T]
    Converts this type into a shared reference of the (usually inferred) input type.
    source§
    impl<T> Clone for Iter<'_, T>
    source§
    fn clone(&self) -> Iter<'_, T> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    1.9.0 · source§
    impl<T> Debug for Iter<'_, T>
    where
│ │ │ │ +    T: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    1.70.0 · source§
    impl<T> Default for Iter<'_, T>
    source§
    fn default() -> Iter<'_, T> ⓘ
    Creates an empty slice iterator.
    
│ │ │ │  
│ │ │ │  
    let iter: Iter < '_, u8 > = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    
│ │ │ │ -
    source§
    impl<'a, T> DoubleEndedIterator for Iter<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a T>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<&'a T>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for Iter<'_, T>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for Iter<'a, T>
    §
    type Item = &'a T
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a T>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a T>
    Returns the nth element of the iterator. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn last(self) -> Option<&'a T>
    Consumes the iterator, returning the last element. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    F: FnMut(B, <Iter<'a, T> as Iterator>::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Iter<'a, T>: Sized,
│ │ │ │ -    F: FnMut(<Iter<'a, T> as Iterator>::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Iter<'a, T>: Sized,
│ │ │ │ -    F: FnMut(<Iter<'a, T> as Iterator>::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Iter<'a, T>: Sized,
│ │ │ │ -    F: FnMut(<Iter<'a, T> as Iterator>::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<<Iter<'a, T> as Iterator>::Item>
    where
│ │ │ │ -    Iter<'a, T>: Sized,
│ │ │ │ -    P: FnMut(&<Iter<'a, T> as Iterator>::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Iter<'a, T>: Sized,
│ │ │ │ -    F: FnMut(<Iter<'a, T> as Iterator>::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Iter<'a, T>: Sized,
│ │ │ │ -    P: FnMut(<Iter<'a, T> as Iterator>::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    P: FnMut(<Iter<'a, T> as Iterator>::Item) -> bool,
│ │ │ │ -    Iter<'a, T>: Sized + ExactSizeIterator + DoubleEndedIterator,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ -index. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Iter<'a, T>: Sized,
│ │ │ │ -    F: FnMut(&<Iter<'a, T> as Iterator>::Item, &<Iter<'a, T> as Iterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    source§
    impl<'a, T> DoubleEndedIterator for Iter<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a T>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<&'a T>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for Iter<'_, T>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for Iter<'a, T>
    §
    type Item = &'a T
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a T>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a T>
    Returns the nth element of the iterator. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn last(self) -> Option<&'a T>
    Consumes the iterator, returning the last element. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    F: FnMut(B, <Iter<'a, T> as Iterator>::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Iter<'a, T>: Sized,
│ │ │ │ +    F: FnMut(<Iter<'a, T> as Iterator>::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Iter<'a, T>: Sized,
│ │ │ │ +    F: FnMut(<Iter<'a, T> as Iterator>::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Iter<'a, T>: Sized,
│ │ │ │ +    F: FnMut(<Iter<'a, T> as Iterator>::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<<Iter<'a, T> as Iterator>::Item>
    where
│ │ │ │ +    Iter<'a, T>: Sized,
│ │ │ │ +    P: FnMut(&<Iter<'a, T> as Iterator>::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Iter<'a, T>: Sized,
│ │ │ │ +    F: FnMut(<Iter<'a, T> as Iterator>::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Iter<'a, T>: Sized,
│ │ │ │ +    P: FnMut(<Iter<'a, T> as Iterator>::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    P: FnMut(<Iter<'a, T> as Iterator>::Item) -> bool,
│ │ │ │ +    Iter<'a, T>: Sized + ExactSizeIterator + DoubleEndedIterator,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ +index. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Iter<'a, T>: Sized,
│ │ │ │ +    F: FnMut(&<Iter<'a, T> as Iterator>::Item, &<Iter<'a, T> as Iterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Iter<'_, T>

    source§

    impl<T> Send for Iter<'_, T>
    where │ │ │ │ - T: Sync,

    source§

    impl<T> Sync for Iter<'_, T>
    where │ │ │ │ - T: Sync,

    source§

    impl<T> TrustedLen for Iter<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Iter<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Iter<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for Iter<'a, T>

    §

    impl<'a, T> UnwindSafe for Iter<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Iter<'_, T>

    source§

    impl<T> Send for Iter<'_, T>
    where │ │ │ │ + T: Sync,

    source§

    impl<T> Sync for Iter<'_, T>
    where │ │ │ │ + T: Sync,

    source§

    impl<T> TrustedLen for Iter<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Iter<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Iter<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for Iter<'a, T>

    §

    impl<'a, T> UnwindSafe for Iter<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.IterMut.html │ │ │ │ @@ -1,26 +1,26 @@ │ │ │ │ IterMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::IterMut

    1.0.0 · source · 
    pub struct IterMut<'a, T>
    where
│ │ │ │ +    
    Struct alloc::slice::IterMut
    1.0.0 · source · 
    pub struct IterMut<'a, T>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    Mutable slice iterator.
    
│ │ │ │ -
    This struct is created by the iter_mut method on slices.
    
│ │ │ │ +
    This struct is created by the iter_mut method on slices.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    // First, we declare a type which has `iter_mut` method to get the `IterMut`
│ │ │ │  // struct (`&[usize]` here):
│ │ │ │  let mut slice = &mut [1, 2, 3];
│ │ │ │  
│ │ │ │  // Then, we iterate over it and increment each element value:
│ │ │ │  for element in slice.iter_mut() {
│ │ │ │      *element += 1;
│ │ │ │  }
│ │ │ │  
│ │ │ │  // We now have "[2, 3, 4]":
│ │ │ │  println!("{slice:?}");
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, T> IterMut<'a, T>
    1.4.0 · source
    pub fn into_slice(self) -> &'a mut [T]
    Views the underlying data as a subslice of the original data.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, T> IterMut<'a, T>
    1.4.0 · source
    pub fn into_slice(self) -> &'a mut [T]
    Views the underlying data as a subslice of the original data.
    
│ │ │ │  
    To avoid creating &mut references that alias, this is forced
│ │ │ │  to consume the iterator.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    // First, we declare a type which has `iter_mut` method to get the `IterMut`
│ │ │ │  // struct (`&[usize]` here):
│ │ │ │ @@ -40,15 +40,15 @@
│ │ │ │      // First we get back the iterator:
│ │ │ │      let mut iter = slice.iter_mut();
│ │ │ │      // We change the value of the first element of the slice returned by the `next` method:
│ │ │ │      *iter.next().unwrap() += 1;
│ │ │ │  }
│ │ │ │  // Now slice is "[2, 2, 3]":
│ │ │ │  println!("{slice:?}");
    Run
    
│ │ │ │ -
    1.53.0 · source
    pub fn as_slice(&self) -> &[T]
    Views the underlying data as a subslice of the original data.
    
│ │ │ │ +
    1.53.0 · source
    pub fn as_slice(&self) -> &[T]
    Views the underlying data as a subslice of the original data.
    
│ │ │ │  
    To avoid creating &mut [T] references that alias, the returned slice
│ │ │ │  borrows its lifetime from the iterator the method is applied on.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    let mut slice: &mut [usize] = &mut [1, 2, 3];
│ │ │ │  
│ │ │ │ @@ -57,15 +57,15 @@
│ │ │ │  // So if we check what the `as_slice` method returns here, we have "[1, 2, 3]":
│ │ │ │  assert_eq!(iter.as_slice(), &[1, 2, 3]);
│ │ │ │  
│ │ │ │  // Next, we move to the second element of the slice:
│ │ │ │  iter.next();
│ │ │ │  // Now `as_slice` returns "[2, 3]":
│ │ │ │  assert_eq!(iter.as_slice(), &[2, 3]);
    Run
    
│ │ │ │ -
    source
    pub fn as_mut_slice(&mut self) -> &mut [T]
    🔬This is a nightly-only experimental API. (slice_iter_mut_as_mut_slice #93079)
    Views the underlying data as a mutable subslice of the original data.
    
│ │ │ │ +
    source
    pub fn as_mut_slice(&mut self) -> &mut [T]
    🔬This is a nightly-only experimental API. (slice_iter_mut_as_mut_slice #93079)
    Views the underlying data as a mutable subslice of the original data.
    
│ │ │ │  
    To avoid creating &mut [T] references that alias, the returned slice
│ │ │ │  borrows its lifetime from the iterator the method is applied on.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    #![feature(slice_iter_mut_as_mut_slice)]
│ │ │ │  
│ │ │ │ @@ -83,222 +83,222 @@
│ │ │ │  mut_slice[2] = 5;
│ │ │ │  
│ │ │ │  // Next, we can move to the second element of the slice, checking that
│ │ │ │  // it yields the value we just wrote:
│ │ │ │  assert_eq!(iter.next(), Some(&mut 4));
│ │ │ │  // Now `as_mut_slice` returns "[2, 5]":
│ │ │ │  assert_eq!(iter.as_mut_slice(), &mut [2, 5]);
    Run
    
│ │ │ │ -
    Trait Implementations§
    1.53.0 · source§
    impl<T> AsRef<[T]> for IterMut<'_, T>
    source§
    fn as_ref(&self) -> &[T]
    Converts this type into a shared reference of the (usually inferred) input type.
    1.9.0 · source§
    impl<T> Debug for IterMut<'_, T>
    where
│ │ │ │ -    T: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    1.70.0 · source§
    impl<T> Default for IterMut<'_, T>
    source§
    fn default() -> IterMut<'_, T> ⓘ
    Creates an empty slice iterator.
    
│ │ │ │ +
    Trait Implementations§
    1.53.0 · source§
    impl<T> AsRef<[T]> for IterMut<'_, T>
    source§
    fn as_ref(&self) -> &[T]
    Converts this type into a shared reference of the (usually inferred) input type.
    1.9.0 · source§
    impl<T> Debug for IterMut<'_, T>
    where
│ │ │ │ +    T: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    1.70.0 · source§
    impl<T> Default for IterMut<'_, T>
    source§
    fn default() -> IterMut<'_, T> ⓘ
    Creates an empty slice iterator.
    
│ │ │ │  
│ │ │ │  
    let iter: IterMut < '_, u8 > = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
    Run
    
│ │ │ │ -
    source§
    impl<'a, T> DoubleEndedIterator for IterMut<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a mut T>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<&'a mut T>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for IterMut<'_, T>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for IterMut<'a, T>
    §
    type Item = &'a mut T
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut T>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a mut T>
    Returns the nth element of the iterator. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn last(self) -> Option<&'a mut T>
    Consumes the iterator, returning the last element. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    F: FnMut(B, <IterMut<'a, T> as Iterator>::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    IterMut<'a, T>: Sized,
│ │ │ │ -    F: FnMut(<IterMut<'a, T> as Iterator>::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    IterMut<'a, T>: Sized,
│ │ │ │ -    F: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    IterMut<'a, T>: Sized,
│ │ │ │ -    F: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(
│ │ │ │ +
    source§
    impl<'a, T> DoubleEndedIterator for IterMut<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a mut T>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<&'a mut T>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for IterMut<'_, T>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for IterMut<'a, T>
    §
    type Item = &'a mut T
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut T>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a mut T>
    Returns the nth element of the iterator. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn last(self) -> Option<&'a mut T>
    Consumes the iterator, returning the last element. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    F: FnMut(B, <IterMut<'a, T> as Iterator>::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    IterMut<'a, T>: Sized,
│ │ │ │ +    F: FnMut(<IterMut<'a, T> as Iterator>::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    IterMut<'a, T>: Sized,
│ │ │ │ +    F: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    IterMut<'a, T>: Sized,
│ │ │ │ +    F: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(
│ │ │ │      &mut self,
│ │ │ │      predicate: P
│ │ │ │ -) -> Option<<IterMut<'a, T> as Iterator>::Item>
    where
│ │ │ │ -    IterMut<'a, T>: Sized,
│ │ │ │ -    P: FnMut(&<IterMut<'a, T> as Iterator>::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    IterMut<'a, T>: Sized,
│ │ │ │ -    F: FnMut(<IterMut<'a, T> as Iterator>::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    IterMut<'a, T>: Sized,
│ │ │ │ -    P: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    P: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool,
│ │ │ │ -    IterMut<'a, T>: Sized + ExactSizeIterator + DoubleEndedIterator,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ -index. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +) -> Option<<IterMut<'a, T> as Iterator>::Item>
    where
│ │ │ │ +    IterMut<'a, T>: Sized,
│ │ │ │ +    P: FnMut(&<IterMut<'a, T> as Iterator>::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    IterMut<'a, T>: Sized,
│ │ │ │ +    F: FnMut(<IterMut<'a, T> as Iterator>::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    IterMut<'a, T>: Sized,
│ │ │ │ +    P: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    P: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool,
│ │ │ │ +    IterMut<'a, T>: Sized + ExactSizeIterator + DoubleEndedIterator,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ +index. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for IterMut<'_, T>

    source§

    impl<T> Send for IterMut<'_, T>
    where │ │ │ │ - T: Send,

    source§

    impl<T> Sync for IterMut<'_, T>
    where │ │ │ │ - T: Sync,

    source§

    impl<T> TrustedLen for IterMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for IterMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for IterMut<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for IterMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for IterMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for IterMut<'_, T>

    source§

    impl<T> Send for IterMut<'_, T>
    where │ │ │ │ + T: Send,

    source§

    impl<T> Sync for IterMut<'_, T>
    where │ │ │ │ + T: Sync,

    source§

    impl<T> TrustedLen for IterMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for IterMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for IterMut<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for IterMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for IterMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunks.html │ │ │ │ @@ -1,222 +1,222 @@ │ │ │ │ RChunks in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::RChunks

    1.31.0 · source · 
    pub struct RChunks<'a, T>
    where
│ │ │ │ +    
    Struct alloc::slice::RChunks
    1.31.0 · source · 
    pub struct RChunks<'a, T>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    An iterator over a slice in (non-overlapping) chunks (chunk_size elements at a
│ │ │ │  time), starting at the end of the slice.
    
│ │ │ │  
    When the slice len is not evenly divided by the chunk size, the last slice
│ │ │ │  of the iteration will be the remainder.
    
│ │ │ │ -
    This struct is created by the rchunks method on slices.
    
│ │ │ │ +
    This struct is created by the rchunks method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let iter = slice.rchunks(2);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<T> Clone for RChunks<'_, T>
    source§
    fn clone(&self) -> RChunks<'_, T> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T> Debug for RChunks<'a, T>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for RChunks<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<<RChunks<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for RChunks<'_, T>
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for RChunks<'a, T>
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<RChunks<'a, T> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<RChunks<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<T> Clone for RChunks<'_, T>
    source§
    fn clone(&self) -> RChunks<'_, T> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T> Debug for RChunks<'a, T>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for RChunks<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<<RChunks<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for RChunks<'_, T>
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for RChunks<'a, T>
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<RChunks<'a, T> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<RChunks<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T> FusedIterator for RChunks<'_, T>

    source§

    impl<T> TrustedLen for RChunks<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for RChunks<'a, T>

    §

    impl<'a, T> RefUnwindSafe for RChunks<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for RChunks<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Sync for RChunks<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for RChunks<'a, T>

    §

    impl<'a, T> UnwindSafe for RChunks<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T> FusedIterator for RChunks<'_, T>

    source§

    impl<T> TrustedLen for RChunks<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for RChunks<'a, T>

    §

    impl<'a, T> RefUnwindSafe for RChunks<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for RChunks<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Sync for RChunks<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for RChunks<'a, T>

    §

    impl<'a, T> UnwindSafe for RChunks<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunksExact.html │ │ │ │ @@ -1,239 +1,239 @@ │ │ │ │ RChunksExact in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::RChunksExact

    1.31.0 · source · 
    pub struct RChunksExact<'a, T>
    where
│ │ │ │ +    
    Struct alloc::slice::RChunksExact
    1.31.0 · source · 
    pub struct RChunksExact<'a, T>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    An iterator over a slice in (non-overlapping) chunks (chunk_size elements at a
│ │ │ │  time), starting at the end of the slice.
    
│ │ │ │  
    When the slice len is not evenly divided by the chunk size, the last
│ │ │ │  up to chunk_size-1 elements will be omitted but can be retrieved from
│ │ │ │  the remainder function from the iterator.
    
│ │ │ │ -
    This struct is created by the rchunks_exact method on slices.
    
│ │ │ │ +
    This struct is created by the rchunks_exact method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let iter = slice.rchunks_exact(2);
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, T> RChunksExact<'a, T>
    source
    pub fn remainder(&self) -> &'a [T]
    Returns the remainder of the original slice that is not going to be
│ │ │ │ +
    Implementations§
    source§
    impl<'a, T> RChunksExact<'a, T>
    source
    pub fn remainder(&self) -> &'a [T]
    Returns the remainder of the original slice that is not going to be
│ │ │ │  returned by the iterator. The returned slice has at most chunk_size-1
│ │ │ │  elements.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let mut iter = slice.rchunks_exact(2);
│ │ │ │  assert_eq!(iter.remainder(), &['l'][..]);
│ │ │ │  assert_eq!(iter.next(), Some(&['e', 'm'][..]));
│ │ │ │  assert_eq!(iter.remainder(), &['l'][..]);
│ │ │ │  assert_eq!(iter.next(), Some(&['o', 'r'][..]));
│ │ │ │  assert_eq!(iter.remainder(), &['l'][..]);
│ │ │ │  assert_eq!(iter.next(), None);
│ │ │ │  assert_eq!(iter.remainder(), &['l'][..]);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, T> Clone for RChunksExact<'a, T>
    source§
    fn clone(&self) -> RChunksExact<'a, T> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T> Debug for RChunksExact<'a, T>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for RChunksExact<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, T> Clone for RChunksExact<'a, T>
    source§
    fn clone(&self) -> RChunksExact<'a, T> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T> Debug for RChunksExact<'a, T>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for RChunksExact<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │      &mut self,
│ │ │ │ -    n: usize
│ │ │ │ -) -> Option<<RChunksExact<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, T> ExactSizeIterator for RChunksExact<'a, T>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T> Iterator for RChunksExact<'a, T>
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<RChunksExact<'a, T> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<RChunksExact<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    n: usize
│ │ │ │ +) -> Option<<RChunksExact<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, T> ExactSizeIterator for RChunksExact<'a, T>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T> Iterator for RChunksExact<'a, T>
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<RChunksExact<'a, T> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<RChunksExact<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T> FusedIterator for RChunksExact<'_, T>

    source§

    impl<T> TrustedLen for RChunksExact<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for RChunksExact<'a, T>

    §

    impl<'a, T> RefUnwindSafe for RChunksExact<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for RChunksExact<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Sync for RChunksExact<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for RChunksExact<'a, T>

    §

    impl<'a, T> UnwindSafe for RChunksExact<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T> FusedIterator for RChunksExact<'_, T>

    source§

    impl<T> TrustedLen for RChunksExact<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for RChunksExact<'a, T>

    §

    impl<'a, T> RefUnwindSafe for RChunksExact<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for RChunksExact<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Sync for RChunksExact<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for RChunksExact<'a, T>

    §

    impl<'a, T> UnwindSafe for RChunksExact<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunksExactMut.html │ │ │ │ @@ -1,226 +1,226 @@ │ │ │ │ RChunksExactMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::RChunksExactMut

    1.31.0 · source · 
    pub struct RChunksExactMut<'a, T>
    where
│ │ │ │ +    
    Struct alloc::slice::RChunksExactMut
    1.31.0 · source · 
    pub struct RChunksExactMut<'a, T>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    An iterator over a slice in (non-overlapping) mutable chunks (chunk_size
│ │ │ │  elements at a time), starting at the end of the slice.
    
│ │ │ │  
    When the slice len is not evenly divided by the chunk size, the last up to
│ │ │ │  chunk_size-1 elements will be omitted but can be retrieved from the
│ │ │ │  into_remainder function from the iterator.
    
│ │ │ │ -
    This struct is created by the rchunks_exact_mut method on slices.
    
│ │ │ │ +
    This struct is created by the rchunks_exact_mut method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let mut slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let iter = slice.rchunks_exact_mut(2);
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, T> RChunksExactMut<'a, T>
    source
    pub fn into_remainder(self) -> &'a mut [T]
    Returns the remainder of the original slice that is not going to be
│ │ │ │ +
    Implementations§
    source§
    impl<'a, T> RChunksExactMut<'a, T>
    source
    pub fn into_remainder(self) -> &'a mut [T]
    Returns the remainder of the original slice that is not going to be
│ │ │ │  returned by the iterator. The returned slice has at most chunk_size-1
│ │ │ │  elements.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, T> Debug for RChunksExactMut<'a, T>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for RChunksExactMut<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a mut [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, T> Debug for RChunksExactMut<'a, T>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for RChunksExactMut<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a mut [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │      &mut self,
│ │ │ │ -    n: usize
│ │ │ │ -) -> Option<<RChunksExactMut<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for RChunksExactMut<'_, T>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T> Iterator for RChunksExactMut<'a, T>
    §
    type Item = &'a mut [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a mut [T]>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<RChunksExactMut<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    n: usize
│ │ │ │ +) -> Option<<RChunksExactMut<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for RChunksExactMut<'_, T>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<'a, T> Iterator for RChunksExactMut<'a, T>
    §
    type Item = &'a mut [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a mut [T]>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<RChunksExactMut<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T> FusedIterator for RChunksExactMut<'_, T>

    source§

    impl<T> Send for RChunksExactMut<'_, T>
    where │ │ │ │ - T: Send,

    source§

    impl<T> Sync for RChunksExactMut<'_, T>
    where │ │ │ │ - T: Sync,

    source§

    impl<T> TrustedLen for RChunksExactMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for RChunksExactMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for RChunksExactMut<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for RChunksExactMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for RChunksExactMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T> FusedIterator for RChunksExactMut<'_, T>

    source§

    impl<T> Send for RChunksExactMut<'_, T>
    where │ │ │ │ + T: Send,

    source§

    impl<T> Sync for RChunksExactMut<'_, T>
    where │ │ │ │ + T: Sync,

    source§

    impl<T> TrustedLen for RChunksExactMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for RChunksExactMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for RChunksExactMut<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for RChunksExactMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for RChunksExactMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RChunksMut.html │ │ │ │ @@ -1,222 +1,222 @@ │ │ │ │ RChunksMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::RChunksMut

    1.31.0 · source · 
    pub struct RChunksMut<'a, T>
    where
│ │ │ │ +    
    Struct alloc::slice::RChunksMut
    1.31.0 · source · 
    pub struct RChunksMut<'a, T>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    An iterator over a slice in (non-overlapping) mutable chunks (chunk_size
│ │ │ │  elements at a time), starting at the end of the slice.
    
│ │ │ │  
    When the slice len is not evenly divided by the chunk size, the last slice
│ │ │ │  of the iteration will be the remainder.
    
│ │ │ │ -
    This struct is created by the rchunks_mut method on slices.
    
│ │ │ │ +
    This struct is created by the rchunks_mut method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let mut slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let iter = slice.rchunks_mut(2);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, T> Debug for RChunksMut<'a, T>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for RChunksMut<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a mut [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, T> Debug for RChunksMut<'a, T>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for RChunksMut<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a mut [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(
│ │ │ │      &mut self,
│ │ │ │ -    n: usize
│ │ │ │ -) -> Option<<RChunksMut<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for RChunksMut<'_, T>
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for RChunksMut<'a, T>
    §
    type Item = &'a mut [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a mut [T]>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<RChunksMut<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    n: usize
│ │ │ │ +) -> Option<<RChunksMut<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for RChunksMut<'_, T>
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for RChunksMut<'a, T>
    §
    type Item = &'a mut [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a mut [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<&'a mut [T]>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<RChunksMut<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T> FusedIterator for RChunksMut<'_, T>

    source§

    impl<T> Send for RChunksMut<'_, T>
    where │ │ │ │ - T: Send,

    source§

    impl<T> Sync for RChunksMut<'_, T>
    where │ │ │ │ - T: Sync,

    source§

    impl<T> TrustedLen for RChunksMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for RChunksMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for RChunksMut<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for RChunksMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for RChunksMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T> FusedIterator for RChunksMut<'_, T>

    source§

    impl<T> Send for RChunksMut<'_, T>
    where │ │ │ │ + T: Send,

    source§

    impl<T> Sync for RChunksMut<'_, T>
    where │ │ │ │ + T: Sync,

    source§

    impl<T> TrustedLen for RChunksMut<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for RChunksMut<'a, T>

    §

    impl<'a, T> RefUnwindSafe for RChunksMut<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Unpin for RChunksMut<'a, T>

    §

    impl<'a, T> !UnwindSafe for RChunksMut<'a, T>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplit.html │ │ │ │ @@ -1,230 +1,230 @@ │ │ │ │ RSplit in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::RSplit

    1.27.0 · source · 
    pub struct RSplit<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::RSplit
    1.27.0 · source · 
    pub struct RSplit<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description
    An iterator over subslices separated by elements that match a predicate
│ │ │ │ +    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description

    An iterator over subslices separated by elements that match a predicate │ │ │ │ function, starting from the end of the slice.

    │ │ │ │ -

    This struct is created by the rsplit method on slices.

    │ │ │ │ +

    This struct is created by the rsplit method on slices.

    │ │ │ │

    §Example

    │ │ │ │ 
    let slice = [11, 22, 33, 0, 44, 55];
│ │ │ │  let iter = slice.rsplit(|num| *num == 0);
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T, P> Clone for RSplit<'_, T, P>
    where │ │ │ │ - P: Clone + FnMut(&T) -> bool,

    source§

    fn clone(&self) -> RSplit<'_, T, P> ⓘ

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T, P> Debug for RSplit<'_, T, P>
    where │ │ │ │ +

    Trait Implementations§

    source§

    impl<T, P> Clone for RSplit<'_, T, P>
    where │ │ │ │ + P: Clone + FnMut(&T) -> bool,

    source§

    fn clone(&self) -> RSplit<'_, T, P> ⓘ

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T, P> Debug for RSplit<'_, T, P>
    where │ │ │ │ T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for RSplit<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for RSplit<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    §

    type Item = &'a [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for RSplit<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for RSplit<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    §

    type Item = &'a [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T, P> FusedIterator for RSplit<'_, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for RSplit<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for RSplit<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for RSplit<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Sync for RSplit<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for RSplit<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for RSplit<'a, T, P>
    where │ │ │ │ - P: UnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T, P> FusedIterator for RSplit<'_, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for RSplit<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for RSplit<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for RSplit<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Sync for RSplit<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for RSplit<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for RSplit<'a, T, P>
    where │ │ │ │ + P: UnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplitMut.html │ │ │ │ @@ -1,226 +1,226 @@ │ │ │ │ RSplitMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::RSplitMut

    1.27.0 · source · 
    pub struct RSplitMut<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::RSplitMut
    1.27.0 · source · 
    pub struct RSplitMut<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description
    An iterator over the subslices of the vector which are separated
│ │ │ │ +    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description

    An iterator over the subslices of the vector which are separated │ │ │ │ by elements that match pred, starting from the end of the slice.

    │ │ │ │ -

    This struct is created by the rsplit_mut method on slices.

    │ │ │ │ +

    This struct is created by the rsplit_mut method on slices.

    │ │ │ │

    §Example

    │ │ │ │ 
    let mut slice = [11, 22, 33, 0, 44, 55];
│ │ │ │  let iter = slice.rsplit_mut(|num| *num == 0);
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T, P> Debug for RSplitMut<'_, T, P>
    where │ │ │ │ +

    Trait Implementations§

    source§

    impl<T, P> Debug for RSplitMut<'_, T, P>
    where │ │ │ │ T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for RSplitMut<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a mut [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for RSplitMut<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    §

    type Item = &'a mut [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for RSplitMut<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a mut [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for RSplitMut<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    §

    type Item = &'a mut [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T, P> FusedIterator for RSplitMut<'_, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for RSplitMut<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for RSplitMut<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for RSplitMut<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Send,

    §

    impl<'a, T, P> Sync for RSplitMut<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for RSplitMut<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for RSplitMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T, P> FusedIterator for RSplitMut<'_, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for RSplitMut<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for RSplitMut<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for RSplitMut<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Send,

    §

    impl<'a, T, P> Sync for RSplitMut<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for RSplitMut<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for RSplitMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplitN.html │ │ │ │ @@ -1,213 +1,213 @@ │ │ │ │ RSplitN in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::RSplitN

    1.0.0 · source · 
    pub struct RSplitN<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::RSplitN
    1.0.0 · source · 
    pub struct RSplitN<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description
    An iterator over subslices separated by elements that match a
│ │ │ │ +    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description

    An iterator over subslices separated by elements that match a │ │ │ │ predicate function, limited to a given number of splits, starting │ │ │ │ from the end of the slice.

    │ │ │ │ -

    This struct is created by the rsplitn method on slices.

    │ │ │ │ +

    This struct is created by the rsplitn method on slices.

    │ │ │ │

    §Example

    │ │ │ │ 
    let slice = [10, 40, 30, 20, 60, 50];
│ │ │ │  let iter = slice.rsplitn(2, |num| *num % 3 == 0);
    Run
    │ │ │ │ -

    Trait Implementations§

    1.9.0 · source§

    impl<T, P> Debug for RSplitN<'_, T, P>
    where │ │ │ │ +

    Trait Implementations§

    1.9.0 · source§

    impl<T, P> Debug for RSplitN<'_, T, P>
    where │ │ │ │ T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> Iterator for RSplitN<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    §

    type Item = &'a [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> Iterator for RSplitN<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    §

    type Item = &'a [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<'a, T, P> FusedIterator for RSplitN<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for RSplitN<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for RSplitN<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for RSplitN<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Sync for RSplitN<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for RSplitN<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for RSplitN<'a, T, P>
    where │ │ │ │ - P: UnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<'a, T, P> FusedIterator for RSplitN<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for RSplitN<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for RSplitN<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for RSplitN<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Sync for RSplitN<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for RSplitN<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for RSplitN<'a, T, P>
    where │ │ │ │ + P: UnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.RSplitNMut.html │ │ │ │ @@ -1,211 +1,211 @@ │ │ │ │ RSplitNMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::RSplitNMut

    1.0.0 · source · 
    pub struct RSplitNMut<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::RSplitNMut
    1.0.0 · source · 
    pub struct RSplitNMut<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description
    An iterator over subslices separated by elements that match a
│ │ │ │ +    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description

    An iterator over subslices separated by elements that match a │ │ │ │ predicate function, limited to a given number of splits, starting │ │ │ │ from the end of the slice.

    │ │ │ │ -

    This struct is created by the rsplitn_mut method on slices.

    │ │ │ │ +

    This struct is created by the rsplitn_mut method on slices.

    │ │ │ │

    §Example

    │ │ │ │ 
    let mut slice = [10, 40, 30, 20, 60, 50];
│ │ │ │  let iter = slice.rsplitn_mut(2, |num| *num % 3 == 0);
    Run
    │ │ │ │ -

    Trait Implementations§

    1.9.0 · source§

    impl<T, P> Debug for RSplitNMut<'_, T, P>
    where │ │ │ │ +

    Trait Implementations§

    1.9.0 · source§

    impl<T, P> Debug for RSplitNMut<'_, T, P>
    where │ │ │ │ T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> Iterator for RSplitNMut<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    §

    type Item = &'a mut [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> Iterator for RSplitNMut<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    §

    type Item = &'a mut [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<'a, T, P> FusedIterator for RSplitNMut<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for RSplitNMut<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for RSplitNMut<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for RSplitNMut<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Send,

    §

    impl<'a, T, P> Sync for RSplitNMut<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for RSplitNMut<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for RSplitNMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<'a, T, P> FusedIterator for RSplitNMut<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for RSplitNMut<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for RSplitNMut<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for RSplitNMut<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Send,

    §

    impl<'a, T, P> Sync for RSplitNMut<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for RSplitNMut<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for RSplitNMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Split.html │ │ │ │ @@ -1,239 +1,239 @@ │ │ │ │ Split in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::Split

    1.0.0 · source · 
    pub struct Split<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::Split
    1.0.0 · source · 
    pub struct Split<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description
    An iterator over subslices separated by elements that match a predicate
│ │ │ │ +    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description

    An iterator over subslices separated by elements that match a predicate │ │ │ │ function.

    │ │ │ │ -

    This struct is created by the split method on slices.

    │ │ │ │ +

    This struct is created by the split method on slices.

    │ │ │ │

    §Example

    │ │ │ │ 
    let slice = [10, 40, 33, 20];
│ │ │ │  let mut iter = slice.split(|num| num % 3 == 0);
    Run
    │ │ │ │ -

    Implementations§

    source§

    impl<'a, T, P> Split<'a, T, P>
    where │ │ │ │ +

    Implementations§

    source§

    impl<'a, T, P> Split<'a, T, P>
    where │ │ │ │ T: 'a, │ │ │ │ - P: FnMut(&T) -> bool,

    source

    pub fn as_slice(&self) -> &'a [T]

    🔬This is a nightly-only experimental API. (split_as_slice #96137)

    Returns a slice which contains items not yet handled by split.

    │ │ │ │ + P: FnMut(&T) -> bool,
    source

    pub fn as_slice(&self) -> &'a [T]

    🔬This is a nightly-only experimental API. (split_as_slice #96137)

    Returns a slice which contains items not yet handled by split.

    │ │ │ │
    §Example
    │ │ │ │ 
    #![feature(split_as_slice)]
│ │ │ │  let slice = [1,2,3,4,5];
│ │ │ │  let mut split = slice.split(|v| v % 2 == 0);
│ │ │ │  assert!(split.next().is_some());
│ │ │ │  assert_eq!(split.as_slice(), &[3,4,5]);
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T, P> Clone for Split<'_, T, P>
    where │ │ │ │ - P: Clone + FnMut(&T) -> bool,

    source§

    fn clone(&self) -> Split<'_, T, P> ⓘ

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.9.0 · source§

    impl<T, P> Debug for Split<'_, T, P>
    where │ │ │ │ +

    Trait Implementations§

    source§

    impl<T, P> Clone for Split<'_, T, P>
    where │ │ │ │ + P: Clone + FnMut(&T) -> bool,

    source§

    fn clone(&self) -> Split<'_, T, P> ⓘ

    Returns a copy of the value. Read more
    source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    1.9.0 · source§

    impl<T, P> Debug for Split<'_, T, P>
    where │ │ │ │ T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for Split<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    §

    type Item = &'a [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for Split<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    §

    type Item = &'a [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T, P> FusedIterator for Split<'_, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for Split<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for Split<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for Split<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Sync for Split<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for Split<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for Split<'a, T, P>
    where │ │ │ │ - P: UnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T, P> FusedIterator for Split<'_, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for Split<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for Split<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for Split<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Sync for Split<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for Split<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for Split<'a, T, P>
    where │ │ │ │ + P: UnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitInclusive.html │ │ │ │ @@ -1,231 +1,231 @@ │ │ │ │ SplitInclusive in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::SplitInclusive

    1.51.0 · source · 
    pub struct SplitInclusive<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::SplitInclusive
    1.51.0 · source · 
    pub struct SplitInclusive<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description
    An iterator over subslices separated by elements that match a predicate
│ │ │ │ +    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description

    An iterator over subslices separated by elements that match a predicate │ │ │ │ function. Unlike Split, it contains the matched part as a terminator │ │ │ │ of the subslice.

    │ │ │ │ -

    This struct is created by the split_inclusive method on slices.

    │ │ │ │ +

    This struct is created by the split_inclusive method on slices.

    │ │ │ │

    §Example

    │ │ │ │ 
    let slice = [10, 40, 33, 20];
│ │ │ │  let mut iter = slice.split_inclusive(|num| num % 3 == 0);
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T, P> Clone for SplitInclusive<'_, T, P>
    where │ │ │ │ - P: Clone + FnMut(&T) -> bool,

    source§

    fn clone(&self) -> SplitInclusive<'_, T, P> ⓘ

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T, P> Debug for SplitInclusive<'_, T, P>
    where │ │ │ │ +

    Trait Implementations§

    source§

    impl<T, P> Clone for SplitInclusive<'_, T, P>
    where │ │ │ │ + P: Clone + FnMut(&T) -> bool,

    source§

    fn clone(&self) -> SplitInclusive<'_, T, P> ⓘ

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T, P> Debug for SplitInclusive<'_, T, P>
    where │ │ │ │ T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for SplitInclusive<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for SplitInclusive<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    §

    type Item = &'a [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for SplitInclusive<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for SplitInclusive<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    §

    type Item = &'a [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T, P> FusedIterator for SplitInclusive<'_, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for SplitInclusive<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for SplitInclusive<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for SplitInclusive<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Sync for SplitInclusive<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for SplitInclusive<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for SplitInclusive<'a, T, P>
    where │ │ │ │ - P: UnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T, P> FusedIterator for SplitInclusive<'_, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for SplitInclusive<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for SplitInclusive<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for SplitInclusive<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Sync for SplitInclusive<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for SplitInclusive<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for SplitInclusive<'a, T, P>
    where │ │ │ │ + P: UnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitInclusiveMut.html │ │ │ │ @@ -1,227 +1,227 @@ │ │ │ │ SplitInclusiveMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::SplitInclusiveMut

    1.51.0 · source · 
    pub struct SplitInclusiveMut<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::SplitInclusiveMut
    1.51.0 · source · 
    pub struct SplitInclusiveMut<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description
    An iterator over the mutable subslices of the vector which are separated
│ │ │ │ +    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description

    An iterator over the mutable subslices of the vector which are separated │ │ │ │ by elements that match pred. Unlike SplitMut, it contains the matched │ │ │ │ parts in the ends of the subslices.

    │ │ │ │ -

    This struct is created by the split_inclusive_mut method on slices.

    │ │ │ │ +

    This struct is created by the split_inclusive_mut method on slices.

    │ │ │ │

    §Example

    │ │ │ │ 
    let mut v = [10, 40, 30, 20, 60, 50];
│ │ │ │  let iter = v.split_inclusive_mut(|num| *num % 3 == 0);
    Run
    │ │ │ │ -

    Trait Implementations§

    source§

    impl<T, P> Debug for SplitInclusiveMut<'_, T, P>
    where │ │ │ │ +

    Trait Implementations§

    source§

    impl<T, P> Debug for SplitInclusiveMut<'_, T, P>
    where │ │ │ │ T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a mut [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    §

    type Item = &'a mut [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a mut [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    §

    type Item = &'a mut [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.0.0 · source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    source§

    impl<T, P> FusedIterator for SplitInclusiveMut<'_, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Send,

    §

    impl<'a, T, P> Sync for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for SplitInclusiveMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    source§

    impl<T, P> FusedIterator for SplitInclusiveMut<'_, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Send,

    §

    impl<'a, T, P> Sync for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for SplitInclusiveMut<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for SplitInclusiveMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitMut.html │ │ │ │ @@ -1,226 +1,226 @@ │ │ │ │ SplitMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::SplitMut

    1.0.0 · source · 
    pub struct SplitMut<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::SplitMut
    1.0.0 · source · 
    pub struct SplitMut<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description
    An iterator over the mutable subslices of the vector which are separated
│ │ │ │ +    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description

    An iterator over the mutable subslices of the vector which are separated │ │ │ │ by elements that match pred.

    │ │ │ │ -

    This struct is created by the split_mut method on slices.

    │ │ │ │ +

    This struct is created by the split_mut method on slices.

    │ │ │ │

    §Example

    │ │ │ │ 
    let mut v = [10, 40, 30, 20, 60, 50];
│ │ │ │  let iter = v.split_mut(|num| *num % 3 == 0);
    Run
    │ │ │ │ -

    Trait Implementations§

    1.9.0 · source§

    impl<T, P> Debug for SplitMut<'_, T, P>
    where │ │ │ │ +

    Trait Implementations§

    1.9.0 · source§

    impl<T, P> Debug for SplitMut<'_, T, P>
    where │ │ │ │ T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a mut [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for SplitMut<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    §

    type Item = &'a mut [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn next_back(&mut self) -> Option<&'a mut [T]>

    Removes and returns an element from the end of the iterator. Read more
    source§

    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§

    fn nth_back(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§

    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    This is the reverse version of Iterator::try_fold(): it takes │ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§

    fn rfold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    An iterator method that reduces the iterator’s elements to a single, │ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§

    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§

    impl<'a, T, P> Iterator for SplitMut<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    §

    type Item = &'a mut [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where │ │ │ │ T: 'a, │ │ │ │ - Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ - P: FnMut(&T) -> bool,

    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ + Self: Sized + DoubleEndedIterator<Item = &'a mut T>, │ │ │ │ + P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T, P> FusedIterator for SplitMut<'_, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for SplitMut<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for SplitMut<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for SplitMut<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Send,

    §

    impl<'a, T, P> Sync for SplitMut<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for SplitMut<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for SplitMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T, P> FusedIterator for SplitMut<'_, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for SplitMut<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for SplitMut<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for SplitMut<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Send,

    §

    impl<'a, T, P> Sync for SplitMut<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for SplitMut<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for SplitMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitN.html │ │ │ │ @@ -1,212 +1,212 @@ │ │ │ │ SplitN in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::SplitN

    1.0.0 · source · 
    pub struct SplitN<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::SplitN
    1.0.0 · source · 
    pub struct SplitN<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description
    An iterator over subslices separated by elements that match a predicate
│ │ │ │ +    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description

    An iterator over subslices separated by elements that match a predicate │ │ │ │ function, limited to a given number of splits.

    │ │ │ │ -

    This struct is created by the splitn method on slices.

    │ │ │ │ +

    This struct is created by the splitn method on slices.

    │ │ │ │

    §Example

    │ │ │ │ 
    let slice = [10, 40, 30, 20, 60, 50];
│ │ │ │  let iter = slice.splitn(2, |num| *num % 3 == 0);
    Run
    │ │ │ │ -

    Trait Implementations§

    1.9.0 · source§

    impl<T, P> Debug for SplitN<'_, T, P>
    where │ │ │ │ +

    Trait Implementations§

    1.9.0 · source§

    impl<T, P> Debug for SplitN<'_, T, P>
    where │ │ │ │ T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> Iterator for SplitN<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    §

    type Item = &'a [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> Iterator for SplitN<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    §

    type Item = &'a [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<'a, T, P> FusedIterator for SplitN<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for SplitN<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for SplitN<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for SplitN<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Sync for SplitN<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for SplitN<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for SplitN<'a, T, P>
    where │ │ │ │ - P: UnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<'a, T, P> FusedIterator for SplitN<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for SplitN<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for SplitN<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for SplitN<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Sync for SplitN<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for SplitN<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> UnwindSafe for SplitN<'a, T, P>
    where │ │ │ │ + P: UnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.SplitNMut.html │ │ │ │ @@ -1,210 +1,210 @@ │ │ │ │ SplitNMut in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::SplitNMut

    1.0.0 · source · 
    pub struct SplitNMut<'a, T, P>
    where
│ │ │ │ +    
    Struct alloc::slice::SplitNMut
    1.0.0 · source · 
    pub struct SplitNMut<'a, T, P>
    where
│ │ │ │      T: 'a,
│ │ │ │ -    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description
    An iterator over subslices separated by elements that match a predicate
│ │ │ │ +    P: FnMut(&T) -> bool,
    { /* private fields */ }
    Expand description

    An iterator over subslices separated by elements that match a predicate │ │ │ │ function, limited to a given number of splits.

    │ │ │ │ -

    This struct is created by the splitn_mut method on slices.

    │ │ │ │ +

    This struct is created by the splitn_mut method on slices.

    │ │ │ │

    §Example

    │ │ │ │ 
    let mut slice = [10, 40, 30, 20, 60, 50];
│ │ │ │  let iter = slice.splitn_mut(2, |num| *num % 3 == 0);
    Run
    │ │ │ │ -

    Trait Implementations§

    1.9.0 · source§

    impl<T, P> Debug for SplitNMut<'_, T, P>
    where │ │ │ │ +

    Trait Implementations§

    1.9.0 · source§

    impl<T, P> Debug for SplitNMut<'_, T, P>
    where │ │ │ │ T: Debug, │ │ │ │ - P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> Iterator for SplitNMut<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    §

    type Item = &'a mut [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ + P: FnMut(&T) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, T, P> Iterator for SplitNMut<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    §

    type Item = &'a mut [T]

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<&'a mut [T]>

    Advances the iterator and returns the next value. Read more
    source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    source§

    fn next_chunk<const N: usize>( │ │ │ │ &mut self │ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ -the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ - Self: Sized, │ │ │ │ - G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ -between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ -element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ -should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ -the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where │ │ │ │ + Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§

    fn count(self) -> usize
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§

    fn last(self) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator starting at the same point, but stepping by │ │ │ │ +the given amount at each iteration. Read more
    source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where │ │ │ │ + Self: Sized, │ │ │ │ + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator │ │ │ │ +between adjacent items of the original iterator. Read more
    source§

    fn map<B, F>(self, f: F) -> Map<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each │ │ │ │ +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element │ │ │ │ +should be yielded. Read more
    source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    source§

    fn enumerate(self) -> Enumerate<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which gives the current iteration count as well as │ │ │ │ +the next value. Read more
    source§

    fn peekable(self) -> Peekable<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods │ │ │ │ to look at the next element of the iterator without consuming it. See │ │ │ │ -their documentation for more information. Read more
    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ -if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ -unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - U: IntoIterator, │ │ │ │ - F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ -the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ - Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ - Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ - B: FromIterator<Self::Item>, │ │ │ │ - Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ - E: Extend<Self::Item>, │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ - Self: Sized, │ │ │ │ - B: Default + Extend<Self::Item>, │ │ │ │ - F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +their documentation for more information. Read more

    source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§

    fn skip(self, n: usize) -> Skip<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    source§

    fn take(self, n: usize) -> Take<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer │ │ │ │ +if the underlying iterator ends sooner. Read more
    source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but │ │ │ │ +unlike fold, produces a new iterator. Read more
    source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + U: IntoIterator, │ │ │ │ + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over │ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(), │ │ │ │ +the windows during mapping overlap as well. Read more
    source§

    fn fuse(self) -> Fuse<Self>
    where │ │ │ │ + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    source§

    fn by_ref(&mut self) -> &mut Self
    where │ │ │ │ + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    source§

    fn collect<B>(self) -> B
    where │ │ │ │ + B: FromIterator<Self::Item>, │ │ │ │ + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where │ │ │ │ + E: Extend<Self::Item>, │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§

    fn partition<B, F>(self, f: F) -> (B, B)
    where │ │ │ │ + Self: Sized, │ │ │ │ + B: Default + Extend<Self::Item>, │ │ │ │ + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<'a, T, P> FusedIterator for SplitNMut<'a, T, P>
    where │ │ │ │ - P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for SplitNMut<'a, T, P>
    where │ │ │ │ - P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for SplitNMut<'a, T, P>
    where │ │ │ │ - P: RefUnwindSafe, │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for SplitNMut<'a, T, P>
    where │ │ │ │ - P: Send, │ │ │ │ - T: Send,

    §

    impl<'a, T, P> Sync for SplitNMut<'a, T, P>
    where │ │ │ │ - P: Sync, │ │ │ │ - T: Sync,

    §

    impl<'a, T, P> Unpin for SplitNMut<'a, T, P>
    where │ │ │ │ - P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for SplitNMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<'a, T, P> FusedIterator for SplitNMut<'a, T, P>
    where │ │ │ │ + P: FnMut(&T) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, T, P> Freeze for SplitNMut<'a, T, P>
    where │ │ │ │ + P: Freeze,

    §

    impl<'a, T, P> RefUnwindSafe for SplitNMut<'a, T, P>
    where │ │ │ │ + P: RefUnwindSafe, │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T, P> Send for SplitNMut<'a, T, P>
    where │ │ │ │ + P: Send, │ │ │ │ + T: Send,

    §

    impl<'a, T, P> Sync for SplitNMut<'a, T, P>
    where │ │ │ │ + P: Sync, │ │ │ │ + T: Sync,

    §

    impl<'a, T, P> Unpin for SplitNMut<'a, T, P>
    where │ │ │ │ + P: Unpin,

    §

    impl<'a, T, P> !UnwindSafe for SplitNMut<'a, T, P>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/struct.Windows.html │ │ │ │ @@ -1,219 +1,219 @@ │ │ │ │ Windows in alloc::slice - Rust
    │ │ │ │ -

    Struct alloc::slice::Windows

    1.0.0 · source · 
    pub struct Windows<'a, T>
    where
│ │ │ │ +    
    Struct alloc::slice::Windows
    1.0.0 · source · 
    pub struct Windows<'a, T>
    where
│ │ │ │      T: 'a,
    { /* private fields */ }
    Expand description
    An iterator over overlapping subslices of length size.
    
│ │ │ │ -
    This struct is created by the windows method on slices.
    
│ │ │ │ +
    This struct is created by the windows method on slices.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let slice = ['r', 'u', 's', 't'];
│ │ │ │  let iter = slice.windows(2);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<T> Clone for Windows<'_, T>
    source§
    fn clone(&self) -> Windows<'_, T> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T> Debug for Windows<'a, T>
    where
│ │ │ │ -    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for Windows<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<<Windows<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for Windows<'_, T>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for Windows<'a, T>
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<Windows<'a, T> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<Windows<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<T> Clone for Windows<'_, T>
    source§
    fn clone(&self) -> Windows<'_, T> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, T> Debug for Windows<'a, T>
    where
│ │ │ │ +    T: Debug + 'a,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, T> DoubleEndedIterator for Windows<'a, T>
    source§
    fn next_back(&mut self) -> Option<&'a [T]>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<<Windows<'a, T> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T> ExactSizeIterator for Windows<'_, T>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<'a, T> Iterator for Windows<'a, T>
    §
    type Item = &'a [T]
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a [T]>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<Windows<'a, T> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn last(self) -> Option<<Windows<'a, T> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate, │ │ │ │ such that all those that return true precede all those that return false. │ │ │ │ -Returns the number of true elements found. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> R, │ │ │ │ - R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> R, │ │ │ │ - R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ -returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ -operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ +Returns the number of true elements found. Read more

    source§

    fn is_partitioned<P>(self, predicate: P) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate, │ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> R, │ │ │ │ + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns │ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> R
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> R, │ │ │ │ + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the │ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§

    fn fold<B, F>(self, init: B, f: F) -> B
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, │ │ │ │ +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing │ │ │ │ +operation. Read more
    source§

    fn try_reduce<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ - R: Try<Output = Self::Item>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ -the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item, Self::Item) -> R, │ │ │ │ + R: Try<Output = Self::Item>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the │ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§

    fn all<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    source§

    fn any<F>(&mut self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns │ │ │ │ +the first non-none result. Read more
    source§

    fn try_find<F, R>( │ │ │ │ &mut self, │ │ │ │ f: F │ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> R, │ │ │ │ - R: Try<Output = bool>, │ │ │ │ - <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ -the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ - P: FnMut(Self::Item) -> bool, │ │ │ │ - Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ -index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ -specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ - B: Ord, │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ -specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ -specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ - Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ - FromA: Default + Extend<A>, │ │ │ │ - FromB: Default + Extend<B>, │ │ │ │ - Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ - T: 'a + Copy, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ - T: 'a + Clone, │ │ │ │ - Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ - Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ - Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ - Self: Sized, │ │ │ │ - S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ - Self: Sized, │ │ │ │ - P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ -this Iterator with those of another. The comparison works like short-circuit │ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> R, │ │ │ │ + R: Try<Output = bool>, │ │ │ │ + <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns │ │ │ │ +the first true result or the first error. Read more
    source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    source§

    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where │ │ │ │ + P: FnMut(Self::Item) -> bool, │ │ │ │ + Self: Sized + ExactSizeIterator + DoubleEndedIterator,

    Searches for an element in an iterator from the right, returning its │ │ │ │ +index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the │ │ │ │ +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where │ │ │ │ + B: Ord, │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the │ │ │ │ +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the │ │ │ │ +specified comparison function. Read more
    source§

    fn rev(self) -> Rev<Self>
    where │ │ │ │ + Self: Sized + DoubleEndedIterator,

    Reverses an iterator’s direction. Read more
    source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where │ │ │ │ + FromA: Default + Extend<A>, │ │ │ │ + FromB: Default + Extend<B>, │ │ │ │ + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>
    where │ │ │ │ + T: 'a + Copy, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    source§

    fn cloned<'a, T>(self) -> Cloned<Self>
    where │ │ │ │ + T: 'a + Clone, │ │ │ │ + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn cycle(self) -> Cycle<Self>
    where │ │ │ │ + Self: Sized + Clone,

    Repeats an iterator endlessly. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where │ │ │ │ + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> S
    where │ │ │ │ + Self: Sized, │ │ │ │ + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> P
    where │ │ │ │ + Self: Sized, │ │ │ │ + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Lexicographically compares the PartialOrd elements of │ │ │ │ +this Iterator with those of another. The comparison works like short-circuit │ │ │ │ evaluation, returning a result without comparing the remaining elements. │ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - I: IntoIterator, │ │ │ │ - F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ -another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ - I: IntoIterator, │ │ │ │ - Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ - Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ -greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ - Self: Sized, │ │ │ │ - F: FnMut(Self::Item) -> K, │ │ │ │ - K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ -function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Windows<'_, T>

    source§

    impl<T> TrustedLen for Windows<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Windows<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Windows<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    §

    impl<'a, T> Send for Windows<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Sync for Windows<'a, T>
    where │ │ │ │ - T: Sync,

    §

    impl<'a, T> Unpin for Windows<'a, T>

    §

    impl<'a, T> UnwindSafe for Windows<'a, T>
    where │ │ │ │ - T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those │ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + I: IntoIterator, │ │ │ │ + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of │ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialEq<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of │ │ │ │ +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> bool
    where │ │ │ │ + I: IntoIterator, │ │ │ │ + Self::Item: PartialOrd<<I as IntoIterator>::Item>, │ │ │ │ + Self: Sized,

    Determines if the elements of this Iterator are lexicographically │ │ │ │ +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(&Self::Item, &Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where │ │ │ │ + Self: Sized, │ │ │ │ + F: FnMut(Self::Item) -> K, │ │ │ │ + K: PartialOrd,

    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction │ │ │ │ +function. Read more
    1.26.0 · source§

    impl<T> FusedIterator for Windows<'_, T>

    source§

    impl<T> TrustedLen for Windows<'_, T>

    Auto Trait Implementations§

    §

    impl<'a, T> Freeze for Windows<'a, T>

    §

    impl<'a, T> RefUnwindSafe for Windows<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    §

    impl<'a, T> Send for Windows<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Sync for Windows<'a, T>
    where │ │ │ │ + T: Sync,

    §

    impl<'a, T> Unpin for Windows<'a, T>

    §

    impl<'a, T> UnwindSafe for Windows<'a, T>
    where │ │ │ │ + T: RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ -
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ - I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │ +
    source§

    impl<I> IntoIterator for I
    where │ │ │ │ + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T> ToOwned for T
    where │ │ │ │ + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/trait.Concat.html │ │ │ │ @@ -1,14 +1,14 @@ │ │ │ │ Concat in alloc::slice - Rust
    │ │ │ │ -

    Trait alloc::slice::Concat

    source · 
    pub trait Concat<Item: ?Sized> {
│ │ │ │ +    
    Trait alloc::slice::Concat
    source · 
    pub trait Concat<Item: ?Sized> {
│ │ │ │      type Output;
│ │ │ │  
│ │ │ │      // Required method
│ │ │ │ -    fn concat(slice: &Self) -> Self::Output;
│ │ │ │ -}
    🔬This is a nightly-only experimental API. (slice_concat_trait #27747)
    Expand description
    Helper trait for [T]::concat.
    
│ │ │ │ +    fn concat(slice: &Self) -> Self::Output;
│ │ │ │ +}
    🔬This is a nightly-only experimental API. (slice_concat_trait #27747)
    Expand description

    Helper trait for [T]::concat.

    │ │ │ │

    Note: the Item type parameter is not used in this trait, │ │ │ │ but it allows impls to be more generic. │ │ │ │ Without it, we get this error:

    │ │ │ │ 
    error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predica
│ │ │ │     --> library/alloc/src/slice.rs:608:6
│ │ │ │      |
│ │ │ │  608 | impl<T: Clone, V: Borrow<[T]>> Concat for [V] {
│ │ │ │ @@ -23,11 +23,11 @@
│ │ │ │      fn borrow(&self) -> &[u32] { &self.0 }
│ │ │ │  }
│ │ │ │  
│ │ │ │  impl std::borrow::Borrow<[String]> for Foo {
│ │ │ │      fn borrow(&self) -> &[String] { &self.1 }
│ │ │ │  }
    Run
    │ │ │ │

    Required Associated Types§

    source

    type Output

    🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

    The resulting type after concatenation

    │ │ │ │ -

    Required Methods§

    source

    fn concat(slice: &Self) -> Self::Output

    🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

    Implementation of [T]::concat

    │ │ │ │ -

    Object Safety§

    This trait is not object safe.

    Implementors§

    source§

    impl<S: Borrow<str>> Concat<str> for [S]

    Note: str in Concat<str> is not meaningful here. │ │ │ │ +

    Required Methods§

    source

    fn concat(slice: &Self) -> Self::Output

    🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

    Implementation of [T]::concat

    │ │ │ │ +

    Object Safety§

    This trait is not object safe.

    Implementors§

    source§

    impl<S: Borrow<str>> Concat<str> for [S]

    Note: str in Concat<str> is not meaningful here. │ │ │ │ This type parameter of the trait only exists to enable another impl.

    │ │ │ │ -
    §

    type Output = String

    source§

    impl<T: Clone, V: Borrow<[T]>> Concat<T> for [V]

    §

    type Output = Vec<T>

    │ │ │ │ +
    §

    type Output = String

    source§

    impl<T: Clone, V: Borrow<[T]>> Concat<T> for [V]

    §

    type Output = Vec<T>

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/trait.Join.html │ │ │ │ @@ -1,10 +1,10 @@ │ │ │ │ Join in alloc::slice - Rust
    │ │ │ │

    Trait alloc::slice::Join

    source · 
    pub trait Join<Separator> {
│ │ │ │      type Output;
│ │ │ │  
│ │ │ │      // Required method
│ │ │ │ -    fn join(slice: &Self, sep: Separator) -> Self::Output;
│ │ │ │ -}
    🔬This is a nightly-only experimental API. (slice_concat_trait #27747)
    Expand description

    Helper trait for [T]::join

    │ │ │ │ + fn join(slice: &Self, sep: Separator) -> Self::Output; │ │ │ │ +}
    🔬This is a nightly-only experimental API. (slice_concat_trait #27747)
    Expand description

    Helper trait for [T]::join

    │ │ │ │

    Required Associated Types§

    source

    type Output

    🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

    The resulting type after concatenation

    │ │ │ │ -

    Required Methods§

    source

    fn join(slice: &Self, sep: Separator) -> Self::Output

    🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

    Implementation of [T]::join

    │ │ │ │ -

    Object Safety§

    This trait is not object safe.

    Implementors§

    source§

    impl<S: Borrow<str>> Join<&str> for [S]

    §

    type Output = String

    source§

    impl<T: Clone, V: Borrow<[T]>> Join<&[T]> for [V]

    §

    type Output = Vec<T>

    source§

    impl<T: Clone, V: Borrow<[T]>> Join<&T> for [V]

    §

    type Output = Vec<T>

    │ │ │ │ +

    Required Methods§

    source

    fn join(slice: &Self, sep: Separator) -> Self::Output

    🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

    Implementation of [T]::join

    │ │ │ │ +

    Object Safety§

    This trait is not object safe.

    Implementors§

    source§

    impl<S: Borrow<str>> Join<&str> for [S]

    §

    type Output = String

    source§

    impl<T: Clone, V: Borrow<[T]>> Join<&[T]> for [V]

    §

    type Output = Vec<T>

    source§

    impl<T: Clone, V: Borrow<[T]>> Join<&T> for [V]

    §

    type Output = Vec<T>

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/slice/trait.SliceIndex.html │ │ │ │ @@ -1,49 +1,49 @@ │ │ │ │ SliceIndex in alloc::slice - Rust
    │ │ │ │ -

    Trait alloc::slice::SliceIndex

    1.28.0 · source · 
    pub unsafe trait SliceIndex<T>: Sealed
    where
│ │ │ │ -    T: ?Sized,
    {
│ │ │ │ -    type Output: ?Sized;
│ │ │ │ +    
    Trait alloc::slice::SliceIndex
    1.28.0 · source · 
    pub unsafe trait SliceIndex<T>: Sealed
    where
│ │ │ │ +    T: ?Sized,
    {
│ │ │ │ +    type Output: ?Sized;
│ │ │ │  
│ │ │ │      // Required methods
│ │ │ │ -    fn get(self, slice: &T) -> Option<&Self::Output>;
│ │ │ │ -    fn get_mut(self, slice: &mut T) -> Option<&mut Self::Output>;
│ │ │ │ -    unsafe fn get_unchecked(self, slice: *const T) -> *const Self::Output;
│ │ │ │ -    unsafe fn get_unchecked_mut(self, slice: *mut T) -> *mut Self::Output;
│ │ │ │ -    fn index(self, slice: &T) -> &Self::Output;
│ │ │ │ -    fn index_mut(self, slice: &mut T) -> &mut Self::Output;
│ │ │ │ +    fn get(self, slice: &T) -> Option<&Self::Output>;
│ │ │ │ +    fn get_mut(self, slice: &mut T) -> Option<&mut Self::Output>;
│ │ │ │ +    unsafe fn get_unchecked(self, slice: *const T) -> *const Self::Output;
│ │ │ │ +    unsafe fn get_unchecked_mut(self, slice: *mut T) -> *mut Self::Output;
│ │ │ │ +    fn index(self, slice: &T) -> &Self::Output;
│ │ │ │ +    fn index_mut(self, slice: &mut T) -> &mut Self::Output;
│ │ │ │  }
    Expand description
    A helper trait used for indexing operations.
    
│ │ │ │  
    Implementations of this trait have to promise that if the argument
│ │ │ │  to get_unchecked(_mut) is a safe reference, then so is the result.
    
│ │ │ │ -
    Required Associated Types§
    source
    type Output: ?Sized
    The output type returned by methods.
    
│ │ │ │ -
    Required Methods§
    source
    fn get(self, slice: &T) -> Option<&Self::Output>
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a shared reference to the output at this location, if in
│ │ │ │ +
    Required Associated Types§
    source
    type Output: ?Sized
    The output type returned by methods.
    
│ │ │ │ +
    Required Methods§
    source
    fn get(self, slice: &T) -> Option<&Self::Output>
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a shared reference to the output at this location, if in
│ │ │ │  bounds.
    
│ │ │ │ -
    source
    fn get_mut(self, slice: &mut T) -> Option<&mut Self::Output>
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a mutable reference to the output at this location, if in
│ │ │ │ +
    source
    fn get_mut(self, slice: &mut T) -> Option<&mut Self::Output>
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a mutable reference to the output at this location, if in
│ │ │ │  bounds.
    
│ │ │ │ -
    source
    unsafe fn get_unchecked(self, slice: *const T) -> *const Self::Output
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a pointer to the output at this location, without
│ │ │ │ +
    source
    unsafe fn get_unchecked(self, slice: *const T) -> *const Self::Output
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a pointer to the output at this location, without
│ │ │ │  performing any bounds checking.
│ │ │ │  Calling this method with an out-of-bounds index or a dangling slice pointer
│ │ │ │  is undefined behavior even if the resulting pointer is not used.
    
│ │ │ │ -
    source
    unsafe fn get_unchecked_mut(self, slice: *mut T) -> *mut Self::Output
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a mutable pointer to the output at this location, without
│ │ │ │ +
    source
    unsafe fn get_unchecked_mut(self, slice: *mut T) -> *mut Self::Output
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a mutable pointer to the output at this location, without
│ │ │ │  performing any bounds checking.
│ │ │ │  Calling this method with an out-of-bounds index or a dangling slice pointer
│ │ │ │  is undefined behavior even if the resulting pointer is not used.
    
│ │ │ │ -
    source
    fn index(self, slice: &T) -> &Self::Output
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a shared reference to the output at this location, panicking
│ │ │ │ +
    source
    fn index(self, slice: &T) -> &Self::Output
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a shared reference to the output at this location, panicking
│ │ │ │  if out of bounds.
    
│ │ │ │ -
    source
    fn index_mut(self, slice: &mut T) -> &mut Self::Output
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a mutable reference to the output at this location, panicking
│ │ │ │ +
    source
    fn index_mut(self, slice: &mut T) -> &mut Self::Output
    🔬This is a nightly-only experimental API. (slice_index_methods)
    Returns a mutable reference to the output at this location, panicking
│ │ │ │  if out of bounds.
    
│ │ │ │ -
    Implementors§
    1.73.0 · source§
    impl SliceIndex<str> for (Bound<usize>, Bound<usize>)
    Implements substring slicing for arbitrary bounds.
    
│ │ │ │ +
    Implementors§
    1.73.0 · source§
    impl SliceIndex<str> for (Bound<usize>, Bound<usize>)
    Implements substring slicing for arbitrary bounds.
    
│ │ │ │  
    Returns a slice of the given string bounded by the byte indices
│ │ │ │  provided by each bound.
    
│ │ │ │  
    This operation is O(1).
    
│ │ │ │  
    §Panics
    
│ │ │ │  
    Panics if begin or end (if it exists and once adjusted for
│ │ │ │  inclusion/exclusion) does not point to the starting byte offset of
│ │ │ │  a character (as defined by is_char_boundary), if begin > end, or if
│ │ │ │  end > len.
    
│ │ │ │ -
    §
    type Output = str
    1.20.0 (const: unstable) · source§
    impl SliceIndex<str> for Range<usize>
    Implements substring slicing with syntax &self[begin .. end] or &mut self[begin .. end].
    
│ │ │ │ +
    §
    type Output = str
    1.20.0 (const: unstable) · source§
    impl SliceIndex<str> for Range<usize>
    Implements substring slicing with syntax &self[begin .. end] or &mut self[begin .. end].
    
│ │ │ │  
    Returns a slice of the given string from the byte range
│ │ │ │  [begin, end).
    
│ │ │ │  
    This operation is O(1).
    
│ │ │ │  
    Prior to 1.20.0, these indexing operations were still supported by
│ │ │ │  direct implementation of Index and IndexMut.
    
│ │ │ │  
    §Panics
    
│ │ │ │  
    Panics if begin or end does not point to the starting byte offset of
│ │ │ │ @@ -60,52 +60,52 @@
│ │ │ │  // &s[2 ..3];
│ │ │ │  
│ │ │ │  // byte 8 lies within `老`
│ │ │ │  // &s[1 .. 8];
│ │ │ │  
│ │ │ │  // byte 100 is outside the string
│ │ │ │  // &s[3 .. 100];
    Run
    │ │ │ │ -
    §

    type Output = str

    1.20.0 (const: unstable) · source§

    impl SliceIndex<str> for RangeFrom<usize>

    Implements substring slicing with syntax &self[begin ..] or &mut self[begin ..].

    │ │ │ │ +
    §

    type Output = str

    1.20.0 (const: unstable) · source§

    impl SliceIndex<str> for RangeFrom<usize>

    Implements substring slicing with syntax &self[begin ..] or &mut self[begin ..].

    │ │ │ │

    Returns a slice of the given string from the byte range [begin, len). │ │ │ │ Equivalent to &self[begin .. len] or &mut self[begin .. len].

    │ │ │ │

    This operation is O(1).

    │ │ │ │

    Prior to 1.20.0, these indexing operations were still supported by │ │ │ │ direct implementation of Index and IndexMut.

    │ │ │ │

    §Panics

    │ │ │ │

    Panics if begin does not point to the starting byte offset of │ │ │ │ a character (as defined by is_char_boundary), or if begin > len.

    │ │ │ │ -
    §

    type Output = str

    1.20.0 (const: unstable) · source§

    impl SliceIndex<str> for RangeFull

    Implements substring slicing with syntax &self[..] or &mut self[..].

    │ │ │ │ +
    §

    type Output = str

    1.20.0 (const: unstable) · source§

    impl SliceIndex<str> for RangeFull

    Implements substring slicing with syntax &self[..] or &mut self[..].

    │ │ │ │

    Returns a slice of the whole string, i.e., returns &self or &mut self. Equivalent to &self[0 .. len] or &mut self[0 .. len]. Unlike │ │ │ │ other indexing operations, this can never panic.

    │ │ │ │

    This operation is O(1).

    │ │ │ │

    Prior to 1.20.0, these indexing operations were still supported by │ │ │ │ direct implementation of Index and IndexMut.

    │ │ │ │

    Equivalent to &self[0 .. len] or &mut self[0 .. len].

    │ │ │ │ -
    §

    type Output = str

    1.26.0 (const: unstable) · source§

    impl SliceIndex<str> for RangeInclusive<usize>

    Implements substring slicing with syntax &self[begin ..= end] or &mut self[begin ..= end].

    │ │ │ │ +
    §

    type Output = str

    1.26.0 (const: unstable) · source§

    impl SliceIndex<str> for RangeInclusive<usize>

    Implements substring slicing with syntax &self[begin ..= end] or &mut self[begin ..= end].

    │ │ │ │

    Returns a slice of the given string from the byte range │ │ │ │ [begin, end]. Equivalent to &self [begin .. end + 1] or &mut self[begin .. end + 1], except if end has the maximum value for │ │ │ │ usize.

    │ │ │ │

    This operation is O(1).

    │ │ │ │

    §Panics

    │ │ │ │

    Panics if begin does not point to the starting byte offset of │ │ │ │ a character (as defined by is_char_boundary), if end does not point │ │ │ │ to the ending byte offset of a character (end + 1 is either a starting │ │ │ │ byte offset or equal to len), if begin > end, or if end >= len.

    │ │ │ │ -
    §

    type Output = str

    1.20.0 (const: unstable) · source§

    impl SliceIndex<str> for RangeTo<usize>

    Implements substring slicing with syntax &self[.. end] or &mut self[.. end].

    │ │ │ │ +
    §

    type Output = str

    1.20.0 (const: unstable) · source§

    impl SliceIndex<str> for RangeTo<usize>

    Implements substring slicing with syntax &self[.. end] or &mut self[.. end].

    │ │ │ │

    Returns a slice of the given string from the byte range [0, end). │ │ │ │ Equivalent to &self[0 .. end] or &mut self[0 .. end].

    │ │ │ │

    This operation is O(1).

    │ │ │ │

    Prior to 1.20.0, these indexing operations were still supported by │ │ │ │ direct implementation of Index and IndexMut.

    │ │ │ │

    §Panics

    │ │ │ │

    Panics if end does not point to the starting byte offset of a │ │ │ │ character (as defined by is_char_boundary), or if end > len.

    │ │ │ │ -
    §

    type Output = str

    1.26.0 (const: unstable) · source§

    impl SliceIndex<str> for RangeToInclusive<usize>

    Implements substring slicing with syntax &self[..= end] or &mut self[..= end].

    │ │ │ │ +
    §

    type Output = str

    1.26.0 (const: unstable) · source§

    impl SliceIndex<str> for RangeToInclusive<usize>

    Implements substring slicing with syntax &self[..= end] or &mut self[..= end].

    │ │ │ │

    Returns a slice of the given string from the byte range [0, end]. │ │ │ │ Equivalent to &self [0 .. end + 1], except if end has the maximum │ │ │ │ value for usize.

    │ │ │ │

    This operation is O(1).

    │ │ │ │

    §Panics

    │ │ │ │

    Panics if end does not point to the ending byte offset of a character │ │ │ │ (end + 1 is either a starting byte offset as defined by │ │ │ │ is_char_boundary, or equal to len), or if end >= len.

    │ │ │ │ -
    §

    type Output = str

    1.53.0 · source§

    impl<T> SliceIndex<[T]> for (Bound<usize>, Bound<usize>)

    §

    type Output = [T]

    1.15.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for usize

    §

    type Output = T

    1.15.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for Range<usize>

    §

    type Output = [T]

    1.15.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for RangeFrom<usize>

    §

    type Output = [T]

    1.15.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for RangeFull

    §

    type Output = [T]

    1.26.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for RangeInclusive<usize>

    §

    type Output = [T]

    1.15.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for RangeTo<usize>

    §

    type Output = [T]

    1.26.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for RangeToInclusive<usize>

    §

    type Output = [T]

    │ │ │ │ +
    §

    type Output = str

    1.53.0 · source§

    impl<T> SliceIndex<[T]> for (Bound<usize>, Bound<usize>)

    §

    type Output = [T]

    1.15.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for usize

    §

    type Output = T

    1.15.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for Range<usize>

    §

    type Output = [T]

    1.15.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for RangeFrom<usize>

    §

    type Output = [T]

    1.15.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for RangeFull

    §

    type Output = [T]

    1.26.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for RangeInclusive<usize>

    §

    type Output = [T]

    1.15.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for RangeTo<usize>

    §

    type Output = [T]

    1.26.0 (const: unstable) · source§

    impl<T> SliceIndex<[T]> for RangeToInclusive<usize>

    §

    type Output = [T]

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_boxed_utf8_unchecked.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ from_boxed_utf8_unchecked in alloc::str - Rust
    │ │ │ │ -

    Function alloc::str::from_boxed_utf8_unchecked

    1.20.0 · source · 
    pub unsafe fn from_boxed_utf8_unchecked(v: Box<[u8]>) -> Box<str>
    Expand description

    Converts a boxed slice of bytes to a boxed string slice without checking │ │ │ │ +

    Function alloc::str::from_boxed_utf8_unchecked

    1.20.0 · source · 
    pub unsafe fn from_boxed_utf8_unchecked(v: Box<[u8]>) -> Box<str>
    Expand description

    Converts a boxed slice of bytes to a boxed string slice without checking │ │ │ │ that the string contains valid UTF-8.

    │ │ │ │

    §Examples

    │ │ │ │ 
    let smile_utf8 = Box::new([226, 152, 186]);
│ │ │ │  let smile = unsafe { std::str::from_boxed_utf8_unchecked(smile_utf8) };
│ │ │ │  
│ │ │ │  assert_eq!("☺", &*smile);
    Run
    │ │ │ │
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_raw_parts.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ from_raw_parts in alloc::str - Rust
    │ │ │ │ -

    Function alloc::str::from_raw_parts

    const: unstable · source · 
    pub unsafe fn from_raw_parts<'a>(ptr: *const u8, len: usize) -> &'a str
    🔬This is a nightly-only experimental API. (str_from_raw_parts #119206)
    Expand description

    Creates an &str from a pointer and a length.

    │ │ │ │ +

    Function alloc::str::from_raw_parts

    const: unstable · source · 
    pub unsafe fn from_raw_parts<'a>(ptr: *const u8, len: usize) -> &'a str
    🔬This is a nightly-only experimental API. (str_from_raw_parts #119206)
    Expand description

    Creates an &str from a pointer and a length.

    │ │ │ │

    The pointed-to bytes must be valid UTF-8. │ │ │ │ If this might not be the case, use str::from_utf8(slice::from_raw_parts(ptr, len)), │ │ │ │ which will return an Err if the data isn’t valid UTF-8.

    │ │ │ │

    This function is the str equivalent of slice::from_raw_parts. │ │ │ │ See that function’s documentation for safety concerns and examples.

    │ │ │ │

    The mutable version of this function is from_raw_parts_mut.

    │ │ │ │
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_raw_parts_mut.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ from_raw_parts_mut in alloc::str - Rust
    │ │ │ │ -

    Function alloc::str::from_raw_parts_mut

    const: unstable · source · 
    pub unsafe fn from_raw_parts_mut<'a>(ptr: *mut u8, len: usize) -> &'a str
    🔬This is a nightly-only experimental API. (str_from_raw_parts #119206)
    Expand description

    Creates an &mut str from a pointer and a length.

    │ │ │ │ +

    Function alloc::str::from_raw_parts_mut

    const: unstable · source · 
    pub unsafe fn from_raw_parts_mut<'a>(ptr: *mut u8, len: usize) -> &'a str
    🔬This is a nightly-only experimental API. (str_from_raw_parts #119206)
    Expand description

    Creates an &mut str from a pointer and a length.

    │ │ │ │

    The pointed-to bytes must be valid UTF-8. │ │ │ │ If this might not be the case, use str::from_utf8_mut(slice::from_raw_parts_mut(ptr, len)), │ │ │ │ which will return an Err if the data isn’t valid UTF-8.

    │ │ │ │

    This function is the str equivalent of slice::from_raw_parts_mut. │ │ │ │ See that function’s documentation for safety concerns and examples.

    │ │ │ │

    The immutable version of this function is from_raw_parts.

    │ │ │ │
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8.html │ │ │ │ @@ -1,22 +1,22 @@ │ │ │ │ from_utf8 in alloc::str - Rust
    │ │ │ │ -

    Function alloc::str::from_utf8

    1.0.0 (const: 1.63.0) · source · 
    pub const fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error>
    Expand description

    Converts a slice of bytes to a string slice.

    │ │ │ │ -

    A string slice (&str) is made of bytes (u8), and a byte slice │ │ │ │ -(&[u8]) is made of bytes, so this function converts between │ │ │ │ -the two. Not all byte slices are valid string slices, however: &str requires │ │ │ │ +

    Function alloc::str::from_utf8

    1.0.0 (const: 1.63.0) · source · 
    pub const fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error>
    Expand description

    Converts a slice of bytes to a string slice.

    │ │ │ │ +

    A string slice (&str) is made of bytes (u8), and a byte slice │ │ │ │ +(&[u8]) is made of bytes, so this function converts between │ │ │ │ +the two. Not all byte slices are valid string slices, however: &str requires │ │ │ │ that it is valid UTF-8. from_utf8() checks to ensure that the bytes are valid │ │ │ │ UTF-8, and then does the conversion.

    │ │ │ │

    If you are sure that the byte slice is valid UTF-8, and you don’t want to │ │ │ │ incur the overhead of the validity check, there is an unsafe version of │ │ │ │ this function, from_utf8_unchecked, which has the same │ │ │ │ behavior but skips the check.

    │ │ │ │

    If you need a String instead of a &str, consider │ │ │ │ String::from_utf8.

    │ │ │ │

    Because you can stack-allocate a [u8; N], and you can take a │ │ │ │ -&[u8] of it, this function is one way to have a │ │ │ │ +&[u8] of it, this function is one way to have a │ │ │ │ stack-allocated string. There is an example of this in the │ │ │ │ examples section below.

    │ │ │ │

    §Errors

    │ │ │ │

    Returns Err if the slice is not UTF-8 with a description as to why the │ │ │ │ provided slice is not UTF-8.

    │ │ │ │

    §Examples

    │ │ │ │

    Basic usage:

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8_mut.html │ │ │ │ @@ -1,9 +1,9 @@ │ │ │ │ from_utf8_mut in alloc::str - Rust
    │ │ │ │ -

    Function alloc::str::from_utf8_mut

    1.20.0 (const: unstable) · source · 
    pub fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error>
    Expand description

    Converts a mutable slice of bytes to a mutable string slice.

    │ │ │ │ +

    Function alloc::str::from_utf8_mut

    1.20.0 (const: unstable) · source · 
    pub fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error>
    Expand description

    Converts a mutable slice of bytes to a mutable string slice.

    │ │ │ │

    §Examples

    │ │ │ │

    Basic usage:

    │ │ │ │ │ │ │ │ 
    use std::str;
│ │ │ │  
│ │ │ │  // "Hello, Rust!" as a mutable vector
│ │ │ │  let mut hellorust = vec![72, 101, 108, 108, 111, 44, 32, 82, 117, 115, 116, 33];
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8_unchecked.html
│ │ │ │ @@ -1,9 +1,9 @@
│ │ │ │  from_utf8_unchecked in alloc::str - Rust
    
│ │ │ │ -    
    Function alloc::str::from_utf8_unchecked
    1.0.0 (const: 1.55.0) · source · 
    pub const unsafe fn from_utf8_unchecked(v: &[u8]) -> &str
    Expand description
    Converts a slice of bytes to a string slice without checking
│ │ │ │ +    
    Function alloc::str::from_utf8_unchecked
    1.0.0 (const: 1.55.0) · source · 
    pub const unsafe fn from_utf8_unchecked(v: &[u8]) -> &str
    Expand description
    Converts a slice of bytes to a string slice without checking
│ │ │ │  that the string contains valid UTF-8.
    
│ │ │ │  
    See the safe version, from_utf8, for more information.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    The bytes passed in must be valid UTF-8.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/fn.from_utf8_unchecked_mut.html
│ │ │ │ @@ -1,9 +1,9 @@
│ │ │ │  from_utf8_unchecked_mut in alloc::str - Rust
    
│ │ │ │ -    
    Function alloc::str::from_utf8_unchecked_mut
    1.20.0 (const: unstable) · source · 
    pub unsafe fn from_utf8_unchecked_mut(v: &mut [u8]) -> &mut str
    Expand description
    Converts a slice of bytes to a string slice without checking
│ │ │ │ +    
    Function alloc::str::from_utf8_unchecked_mut
    1.20.0 (const: unstable) · source · 
    pub unsafe fn from_utf8_unchecked_mut(v: &mut [u8]) -> &mut str
    Expand description
    Converts a slice of bytes to a string slice without checking
│ │ │ │  that the string contains valid UTF-8; mutable version.
    
│ │ │ │  
    See the immutable version, from_utf8_unchecked() for more information.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    use std::str;
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/index.html
│ │ │ │ @@ -1,14 +1,14 @@
│ │ │ │  alloc::str - Rust
    
│ │ │ │      
    Module alloc::str
    1.0.0 · source · 
    Expand description
    Utilities for the str primitive type.
    
│ │ │ │ -
    See also the str primitive type.
    
│ │ │ │ -
    Modules§
    • patternExperimental
      The string Pattern API.
    Structs§
    Modules§
    • patternExperimental
      The string Pattern API.
    Structs§
    Traits§
    Functions§
    Traits§
    Functions§
    • from_boxed_utf8_unchecked⚠
      Converts a boxed slice of bytes to a boxed string slice without checking
│ │ │ │  that the string contains valid UTF-8.
    • from_utf8
      Converts a slice of bytes to a string slice.
    • from_utf8_mut
      Converts a mutable slice of bytes to a mutable string slice.
    • from_utf8_unchecked⚠
      Converts a slice of bytes to a string slice without checking
│ │ │ │  that the string contains valid UTF-8.
    • from_utf8_unchecked_mut⚠
      Converts a slice of bytes to a string slice without checking
│ │ │ │  that the string contains valid UTF-8; mutable version.
    • from_raw_parts⚠Experimental
      Creates an &str from a pointer and a length.
    • from_raw_parts_mut⚠Experimental
      Creates an &mut str from a pointer and a length.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/enum.SearchStep.html
│ │ │ │ @@ -1,28 +1,28 @@
│ │ │ │  SearchStep in alloc::str::pattern - Rust
    
│ │ │ │ -    
    Enum alloc::str::pattern::SearchStep
    source · 
    pub enum SearchStep {
│ │ │ │ -    Match(usize, usize),
│ │ │ │ -    Reject(usize, usize),
│ │ │ │ +    
    Enum alloc::str::pattern::SearchStep
    source · 
    pub enum SearchStep {
│ │ │ │ +    Match(usize, usize),
│ │ │ │ +    Reject(usize, usize),
│ │ │ │      Done,
│ │ │ │  }
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description
    Result of calling Searcher::next() or ReverseSearcher::next_back().
    
│ │ │ │ -
    Variants§
    §
    Match(usize, usize)
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expresses that a match of the pattern has been found at
│ │ │ │ +
    Variants§
    §
    Match(usize, usize)
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expresses that a match of the pattern has been found at
│ │ │ │  haystack[a..b].
    
│ │ │ │ -
    §
    Reject(usize, usize)
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expresses that haystack[a..b] has been rejected as a possible match
│ │ │ │ +
    §
    Reject(usize, usize)
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expresses that haystack[a..b] has been rejected as a possible match
│ │ │ │  of the pattern.
    
│ │ │ │  
    Note that there might be more than one Reject between two Matches,
│ │ │ │  there is no requirement for them to be combined into one.
    
│ │ │ │  
    §
    Done
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expresses that every byte of the haystack has been visited, ending
│ │ │ │  the iteration.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl Clone for SearchStep
    source§
    fn clone(&self) -> SearchStep
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for SearchStep
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl PartialEq for SearchStep
    source§
    fn eq(&self, other: &SearchStep) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    1.0.0 · source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl Copy for SearchStep
    source§
    impl Eq for SearchStep
    source§
    impl StructuralPartialEq for SearchStep
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl Clone for SearchStep
    source§
    fn clone(&self) -> SearchStep
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for SearchStep
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl PartialEq for SearchStep
    source§
    fn eq(&self, other: &SearchStep) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    1.0.0 · source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl Copy for SearchStep
    source§
    impl Eq for SearchStep
    source§
    impl StructuralPartialEq for SearchStep
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │  
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/index.html │ │ │ │ @@ -1,18 +1,18 @@ │ │ │ │ alloc::str::pattern - Rust
    │ │ │ │ -

    Module alloc::str::pattern

    source ·
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    The string Pattern API.

    │ │ │ │ +

    Module alloc::str::pattern

    source ·
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    The string Pattern API.

    │ │ │ │

    The Pattern API provides a generic mechanism for using different pattern │ │ │ │ types when searching through a string.

    │ │ │ │

    For more details, see the traits Pattern, Searcher, │ │ │ │ ReverseSearcher, and DoubleEndedSearcher.

    │ │ │ │

    Although this API is unstable, it is exposed via stable APIs on the │ │ │ │ -str type.

    │ │ │ │ +str type.

    │ │ │ │

    §Examples

    │ │ │ │

    Pattern is implemented in the stable API for │ │ │ │ -&str, char, slices of char, and functions and closures │ │ │ │ +&str, char, slices of char, and functions and closures │ │ │ │ implementing FnMut(char) -> bool.

    │ │ │ │ │ │ │ │ 
    let s = "Can you find a needle in a haystack?";
│ │ │ │  
│ │ │ │  // &str pattern
│ │ │ │  assert_eq!(s.find("you"), Some(4));
│ │ │ │  // char pattern
│ │ │ │ @@ -20,8 +20,8 @@
│ │ │ │  // array of chars pattern
│ │ │ │  assert_eq!(s.find(&['a', 'e', 'i', 'o', 'u']), Some(1));
│ │ │ │  // slice of chars pattern
│ │ │ │  assert_eq!(s.find(&['a', 'e', 'i', 'o', 'u'][..]), Some(1));
│ │ │ │  // closure pattern
│ │ │ │  assert_eq!(s.find(|c: char| c.is_ascii_punctuation()), Some(35));
    Run
    │ │ │ │

    Structs§

    • CharArrayRefSearcherExperimental
      Associated type for <&[char; N] as Pattern<'a>>::Searcher.
    • CharArraySearcherExperimental
      Associated type for <[char; N] as Pattern<'a>>::Searcher.
    • CharPredicateSearcherExperimental
      Associated type for <F as Pattern<'a>>::Searcher.
    • CharSearcherExperimental
      Associated type for <char as Pattern<'a>>::Searcher.
    • CharSliceSearcherExperimental
      Associated type for <&[char] as Pattern<'a>>::Searcher.
    • StrSearcherExperimental
      Associated type for <&str as Pattern<'a>>::Searcher.

    Enums§

    Traits§

    │ │ │ │ +can be used for a DoubleEndedIterator implementation.
  • PatternExperimental
    A string pattern.
  • ReverseSearcherExperimental
    A reverse searcher for a string pattern.
  • SearcherExperimental
    A searcher for a string pattern.
    • │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharArrayRefSearcher.html │ │ │ │ @@ -1,17 +1,17 @@ │ │ │ │ CharArrayRefSearcher in alloc::str::pattern - Rust
    │ │ │ │ -

    Struct alloc::str::pattern::CharArrayRefSearcher

    source · 
    pub struct CharArrayRefSearcher<'a, 'b, const N: usize>(/* private fields */);
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    Associated type for <&[char; N] as Pattern<'a>>::Searcher.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<'a, 'b, const N: usize> Clone for CharArrayRefSearcher<'a, 'b, N>

    source§

    fn clone(&self) -> CharArrayRefSearcher<'a, 'b, N>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a, 'b, const N: usize> Debug for CharArrayRefSearcher<'a, 'b, N>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, 'b, const N: usize> ReverseSearcher<'a> for CharArrayRefSearcher<'a, 'b, N>

    source§

    fn next_back(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§

    fn next_match_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. │ │ │ │ -See next_back().
    source§

    fn next_reject_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. │ │ │ │ -See next_back().
    source§

    impl<'a, 'b, const N: usize> Searcher<'a> for CharArrayRefSearcher<'a, 'b, N>

    source§

    fn haystack(&self) -> &'a str

    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§

    fn next(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§

    fn next_match(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§

    fn next_reject(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next() │ │ │ │ -and next_match(). Read more
    source§

    impl<'a, 'b, const N: usize> DoubleEndedSearcher<'a> for CharArrayRefSearcher<'a, 'b, N>

    Auto Trait Implementations§

    §

    impl<'a, 'b, const N: usize> Freeze for CharArrayRefSearcher<'a, 'b, N>

    §

    impl<'a, 'b, const N: usize> RefUnwindSafe for CharArrayRefSearcher<'a, 'b, N>

    §

    impl<'a, 'b, const N: usize> Send for CharArrayRefSearcher<'a, 'b, N>

    §

    impl<'a, 'b, const N: usize> Sync for CharArrayRefSearcher<'a, 'b, N>

    §

    impl<'a, 'b, const N: usize> Unpin for CharArrayRefSearcher<'a, 'b, N>

    §

    impl<'a, 'b, const N: usize> UnwindSafe for CharArrayRefSearcher<'a, 'b, N>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Struct alloc::str::pattern::CharArrayRefSearcher

    source · 
    pub struct CharArrayRefSearcher<'a, 'b, const N: usize>(/* private fields */);
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    Associated type for <&[char; N] as Pattern<'a>>::Searcher.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<'a, 'b, const N: usize> Clone for CharArrayRefSearcher<'a, 'b, N>

    source§

    fn clone(&self) -> CharArrayRefSearcher<'a, 'b, N>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a, 'b, const N: usize> Debug for CharArrayRefSearcher<'a, 'b, N>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, 'b, const N: usize> ReverseSearcher<'a> for CharArrayRefSearcher<'a, 'b, N>

    source§

    fn next_back(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§

    fn next_match_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. │ │ │ │ +See next_back().
    source§

    fn next_reject_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. │ │ │ │ +See next_back().
    source§

    impl<'a, 'b, const N: usize> Searcher<'a> for CharArrayRefSearcher<'a, 'b, N>

    source§

    fn haystack(&self) -> &'a str

    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§

    fn next(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§

    fn next_match(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§

    fn next_reject(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next() │ │ │ │ +and next_match(). Read more
    source§

    impl<'a, 'b, const N: usize> DoubleEndedSearcher<'a> for CharArrayRefSearcher<'a, 'b, N>

    Auto Trait Implementations§

    §

    impl<'a, 'b, const N: usize> Freeze for CharArrayRefSearcher<'a, 'b, N>

    §

    impl<'a, 'b, const N: usize> RefUnwindSafe for CharArrayRefSearcher<'a, 'b, N>

    §

    impl<'a, 'b, const N: usize> Send for CharArrayRefSearcher<'a, 'b, N>

    §

    impl<'a, 'b, const N: usize> Sync for CharArrayRefSearcher<'a, 'b, N>

    §

    impl<'a, 'b, const N: usize> Unpin for CharArrayRefSearcher<'a, 'b, N>

    §

    impl<'a, 'b, const N: usize> UnwindSafe for CharArrayRefSearcher<'a, 'b, N>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharArraySearcher.html │ │ │ │ @@ -1,17 +1,17 @@ │ │ │ │ CharArraySearcher in alloc::str::pattern - Rust
    │ │ │ │ -

    Struct alloc::str::pattern::CharArraySearcher

    source · 
    pub struct CharArraySearcher<'a, const N: usize>(/* private fields */);
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    Associated type for <[char; N] as Pattern<'a>>::Searcher.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<'a, const N: usize> Clone for CharArraySearcher<'a, N>

    source§

    fn clone(&self) -> CharArraySearcher<'a, N>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a, const N: usize> Debug for CharArraySearcher<'a, N>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, const N: usize> ReverseSearcher<'a> for CharArraySearcher<'a, N>

    source§

    fn next_back(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§

    fn next_match_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. │ │ │ │ -See next_back().
    source§

    fn next_reject_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. │ │ │ │ -See next_back().
    source§

    impl<'a, const N: usize> Searcher<'a> for CharArraySearcher<'a, N>

    source§

    fn haystack(&self) -> &'a str

    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§

    fn next(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§

    fn next_match(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§

    fn next_reject(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next() │ │ │ │ -and next_match(). Read more
    source§

    impl<'a, const N: usize> DoubleEndedSearcher<'a> for CharArraySearcher<'a, N>

    Auto Trait Implementations§

    §

    impl<'a, const N: usize> Freeze for CharArraySearcher<'a, N>

    §

    impl<'a, const N: usize> RefUnwindSafe for CharArraySearcher<'a, N>

    §

    impl<'a, const N: usize> Send for CharArraySearcher<'a, N>

    §

    impl<'a, const N: usize> Sync for CharArraySearcher<'a, N>

    §

    impl<'a, const N: usize> Unpin for CharArraySearcher<'a, N>

    §

    impl<'a, const N: usize> UnwindSafe for CharArraySearcher<'a, N>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Struct alloc::str::pattern::CharArraySearcher

    source · 
    pub struct CharArraySearcher<'a, const N: usize>(/* private fields */);
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    Associated type for <[char; N] as Pattern<'a>>::Searcher.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<'a, const N: usize> Clone for CharArraySearcher<'a, N>

    source§

    fn clone(&self) -> CharArraySearcher<'a, N>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a, const N: usize> Debug for CharArraySearcher<'a, N>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, const N: usize> ReverseSearcher<'a> for CharArraySearcher<'a, N>

    source§

    fn next_back(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§

    fn next_match_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. │ │ │ │ +See next_back().
    source§

    fn next_reject_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. │ │ │ │ +See next_back().
    source§

    impl<'a, const N: usize> Searcher<'a> for CharArraySearcher<'a, N>

    source§

    fn haystack(&self) -> &'a str

    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§

    fn next(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§

    fn next_match(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§

    fn next_reject(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next() │ │ │ │ +and next_match(). Read more
    source§

    impl<'a, const N: usize> DoubleEndedSearcher<'a> for CharArraySearcher<'a, N>

    Auto Trait Implementations§

    §

    impl<'a, const N: usize> Freeze for CharArraySearcher<'a, N>

    §

    impl<'a, const N: usize> RefUnwindSafe for CharArraySearcher<'a, N>

    §

    impl<'a, const N: usize> Send for CharArraySearcher<'a, N>

    §

    impl<'a, const N: usize> Sync for CharArraySearcher<'a, N>

    §

    impl<'a, const N: usize> Unpin for CharArraySearcher<'a, N>

    §

    impl<'a, const N: usize> UnwindSafe for CharArraySearcher<'a, N>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharPredicateSearcher.html │ │ │ │ @@ -1,30 +1,30 @@ │ │ │ │ CharPredicateSearcher in alloc::str::pattern - Rust
    │ │ │ │ -

    Struct alloc::str::pattern::CharPredicateSearcher

    source · 
    pub struct CharPredicateSearcher<'a, F>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::pattern::CharPredicateSearcher
    source · 
    pub struct CharPredicateSearcher<'a, F>(/* private fields */)
│ │ │ │  where
│ │ │ │ -    F: FnMut(char) -> bool;
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description
    Associated type for <F as Pattern<'a>>::Searcher.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, F> Clone for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: Clone + FnMut(char) -> bool,
    source§
    fn clone(&self) -> CharPredicateSearcher<'a, F>
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<F> Debug for CharPredicateSearcher<'_, F>
    where
│ │ │ │ -    F: FnMut(char) -> bool,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, F> ReverseSearcher<'a> for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: FnMut(char) -> bool,
    source§
    fn next_back(&mut self) -> SearchStep
    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§
    fn next_match_back(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result.
│ │ │ │ -See next_back().
    source§
    fn next_reject_back(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result.
│ │ │ │ -See next_back().
    source§
    impl<'a, F> Searcher<'a> for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: FnMut(char) -> bool,
    source§
    fn haystack(&self) -> &'a str
    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§
    fn next(&mut self) -> SearchStep
    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§
    fn next_match(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§
    fn next_reject(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next()
│ │ │ │ -and next_match(). Read more
    source§
    impl<'a, F> DoubleEndedSearcher<'a> for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: FnMut(char) -> bool,
    Auto Trait Implementations§
    §
    impl<'a, F> Freeze for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: Freeze,
    §
    impl<'a, F> RefUnwindSafe for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: RefUnwindSafe,
    §
    impl<'a, F> Send for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: Send,
    §
    impl<'a, F> Sync for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: Sync,
    §
    impl<'a, F> Unpin for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: Unpin,
    §
    impl<'a, F> UnwindSafe for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +    F: FnMut(char) -> bool;
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    Associated type for <F as Pattern<'a>>::Searcher.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<'a, F> Clone for CharPredicateSearcher<'a, F>
    where │ │ │ │ + F: Clone + FnMut(char) -> bool,

    source§

    fn clone(&self) -> CharPredicateSearcher<'a, F>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<F> Debug for CharPredicateSearcher<'_, F>
    where │ │ │ │ + F: FnMut(char) -> bool,

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, F> ReverseSearcher<'a> for CharPredicateSearcher<'a, F>
    where │ │ │ │ + F: FnMut(char) -> bool,

    source§

    fn next_back(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§

    fn next_match_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. │ │ │ │ +See next_back().
    source§

    fn next_reject_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. │ │ │ │ +See next_back().
    source§

    impl<'a, F> Searcher<'a> for CharPredicateSearcher<'a, F>
    where │ │ │ │ + F: FnMut(char) -> bool,

    source§

    fn haystack(&self) -> &'a str

    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§

    fn next(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§

    fn next_match(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§

    fn next_reject(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next() │ │ │ │ +and next_match(). Read more
    source§

    impl<'a, F> DoubleEndedSearcher<'a> for CharPredicateSearcher<'a, F>
    where │ │ │ │ + F: FnMut(char) -> bool,

    Auto Trait Implementations§

    §

    impl<'a, F> Freeze for CharPredicateSearcher<'a, F>
    where │ │ │ │ + F: Freeze,

    §

    impl<'a, F> RefUnwindSafe for CharPredicateSearcher<'a, F>
    where │ │ │ │ + F: RefUnwindSafe,

    §

    impl<'a, F> Send for CharPredicateSearcher<'a, F>
    where │ │ │ │ + F: Send,

    §

    impl<'a, F> Sync for CharPredicateSearcher<'a, F>
    where │ │ │ │ + F: Sync,

    §

    impl<'a, F> Unpin for CharPredicateSearcher<'a, F>
    where │ │ │ │ + F: Unpin,

    §

    impl<'a, F> UnwindSafe for CharPredicateSearcher<'a, F>
    where │ │ │ │ + F: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharSearcher.html │ │ │ │ @@ -1,17 +1,17 @@ │ │ │ │ CharSearcher in alloc::str::pattern - Rust
    │ │ │ │ -

    Struct alloc::str::pattern::CharSearcher

    source · 
    pub struct CharSearcher<'a> { /* private fields */ }
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    Associated type for <char as Pattern<'a>>::Searcher.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<'a> Clone for CharSearcher<'a>

    source§

    fn clone(&self) -> CharSearcher<'a>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a> Debug for CharSearcher<'a>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a> ReverseSearcher<'a> for CharSearcher<'a>

    source§

    fn next_back(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§

    fn next_match_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. │ │ │ │ -See next_back().
    source§

    fn next_reject_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. │ │ │ │ -See next_back().
    source§

    impl<'a> Searcher<'a> for CharSearcher<'a>

    source§

    fn haystack(&self) -> &'a str

    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§

    fn next(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§

    fn next_match(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§

    fn next_reject(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next() │ │ │ │ -and next_match(). Read more
    source§

    impl<'a> DoubleEndedSearcher<'a> for CharSearcher<'a>

    Auto Trait Implementations§

    §

    impl<'a> Freeze for CharSearcher<'a>

    §

    impl<'a> RefUnwindSafe for CharSearcher<'a>

    §

    impl<'a> Send for CharSearcher<'a>

    §

    impl<'a> Sync for CharSearcher<'a>

    §

    impl<'a> Unpin for CharSearcher<'a>

    §

    impl<'a> UnwindSafe for CharSearcher<'a>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Struct alloc::str::pattern::CharSearcher

    source · 
    pub struct CharSearcher<'a> { /* private fields */ }
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    Associated type for <char as Pattern<'a>>::Searcher.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<'a> Clone for CharSearcher<'a>

    source§

    fn clone(&self) -> CharSearcher<'a>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a> Debug for CharSearcher<'a>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a> ReverseSearcher<'a> for CharSearcher<'a>

    source§

    fn next_back(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§

    fn next_match_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. │ │ │ │ +See next_back().
    source§

    fn next_reject_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. │ │ │ │ +See next_back().
    source§

    impl<'a> Searcher<'a> for CharSearcher<'a>

    source§

    fn haystack(&self) -> &'a str

    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§

    fn next(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§

    fn next_match(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§

    fn next_reject(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next() │ │ │ │ +and next_match(). Read more
    source§

    impl<'a> DoubleEndedSearcher<'a> for CharSearcher<'a>

    Auto Trait Implementations§

    §

    impl<'a> Freeze for CharSearcher<'a>

    §

    impl<'a> RefUnwindSafe for CharSearcher<'a>

    §

    impl<'a> Send for CharSearcher<'a>

    §

    impl<'a> Sync for CharSearcher<'a>

    §

    impl<'a> Unpin for CharSearcher<'a>

    §

    impl<'a> UnwindSafe for CharSearcher<'a>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.CharSliceSearcher.html │ │ │ │ @@ -1,17 +1,17 @@ │ │ │ │ CharSliceSearcher in alloc::str::pattern - Rust
    │ │ │ │ -

    Struct alloc::str::pattern::CharSliceSearcher

    source · 
    pub struct CharSliceSearcher<'a, 'b>(/* private fields */);
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    Associated type for <&[char] as Pattern<'a>>::Searcher.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<'a, 'b> Clone for CharSliceSearcher<'a, 'b>

    source§

    fn clone(&self) -> CharSliceSearcher<'a, 'b>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a, 'b> Debug for CharSliceSearcher<'a, 'b>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, 'b> ReverseSearcher<'a> for CharSliceSearcher<'a, 'b>

    source§

    fn next_back(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§

    fn next_match_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. │ │ │ │ -See next_back().
    source§

    fn next_reject_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. │ │ │ │ -See next_back().
    source§

    impl<'a, 'b> Searcher<'a> for CharSliceSearcher<'a, 'b>

    source§

    fn haystack(&self) -> &'a str

    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§

    fn next(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§

    fn next_match(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§

    fn next_reject(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next() │ │ │ │ -and next_match(). Read more
    source§

    impl<'a, 'b> DoubleEndedSearcher<'a> for CharSliceSearcher<'a, 'b>

    Auto Trait Implementations§

    §

    impl<'a, 'b> Freeze for CharSliceSearcher<'a, 'b>

    §

    impl<'a, 'b> RefUnwindSafe for CharSliceSearcher<'a, 'b>

    §

    impl<'a, 'b> Send for CharSliceSearcher<'a, 'b>

    §

    impl<'a, 'b> Sync for CharSliceSearcher<'a, 'b>

    §

    impl<'a, 'b> Unpin for CharSliceSearcher<'a, 'b>

    §

    impl<'a, 'b> UnwindSafe for CharSliceSearcher<'a, 'b>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Struct alloc::str::pattern::CharSliceSearcher

    source · 
    pub struct CharSliceSearcher<'a, 'b>(/* private fields */);
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    Associated type for <&[char] as Pattern<'a>>::Searcher.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<'a, 'b> Clone for CharSliceSearcher<'a, 'b>

    source§

    fn clone(&self) -> CharSliceSearcher<'a, 'b>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a, 'b> Debug for CharSliceSearcher<'a, 'b>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, 'b> ReverseSearcher<'a> for CharSliceSearcher<'a, 'b>

    source§

    fn next_back(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§

    fn next_match_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. │ │ │ │ +See next_back().
    source§

    fn next_reject_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. │ │ │ │ +See next_back().
    source§

    impl<'a, 'b> Searcher<'a> for CharSliceSearcher<'a, 'b>

    source§

    fn haystack(&self) -> &'a str

    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§

    fn next(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§

    fn next_match(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§

    fn next_reject(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next() │ │ │ │ +and next_match(). Read more
    source§

    impl<'a, 'b> DoubleEndedSearcher<'a> for CharSliceSearcher<'a, 'b>

    Auto Trait Implementations§

    §

    impl<'a, 'b> Freeze for CharSliceSearcher<'a, 'b>

    §

    impl<'a, 'b> RefUnwindSafe for CharSliceSearcher<'a, 'b>

    §

    impl<'a, 'b> Send for CharSliceSearcher<'a, 'b>

    §

    impl<'a, 'b> Sync for CharSliceSearcher<'a, 'b>

    §

    impl<'a, 'b> Unpin for CharSliceSearcher<'a, 'b>

    §

    impl<'a, 'b> UnwindSafe for CharSliceSearcher<'a, 'b>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/struct.StrSearcher.html │ │ │ │ @@ -1,17 +1,17 @@ │ │ │ │ StrSearcher in alloc::str::pattern - Rust
    │ │ │ │ -

    Struct alloc::str::pattern::StrSearcher

    source · 
    pub struct StrSearcher<'a, 'b> { /* private fields */ }
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    Associated type for <&str as Pattern<'a>>::Searcher.

    │ │ │ │ -

    Trait Implementations§

    source§

    impl<'a, 'b> Clone for StrSearcher<'a, 'b>

    source§

    fn clone(&self) -> StrSearcher<'a, 'b>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a, 'b> Debug for StrSearcher<'a, 'b>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, 'b> ReverseSearcher<'a> for StrSearcher<'a, 'b>

    source§

    fn next_back(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§

    fn next_match_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. │ │ │ │ -See next_back().
    source§

    fn next_reject_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. │ │ │ │ -See next_back().
    source§

    impl<'a, 'b> Searcher<'a> for StrSearcher<'a, 'b>

    source§

    fn haystack(&self) -> &'a str

    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§

    fn next(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§

    fn next_match(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§

    fn next_reject(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next() │ │ │ │ -and next_match(). Read more

    Auto Trait Implementations§

    §

    impl<'a, 'b> Freeze for StrSearcher<'a, 'b>

    §

    impl<'a, 'b> RefUnwindSafe for StrSearcher<'a, 'b>

    §

    impl<'a, 'b> Send for StrSearcher<'a, 'b>

    §

    impl<'a, 'b> Sync for StrSearcher<'a, 'b>

    §

    impl<'a, 'b> Unpin for StrSearcher<'a, 'b>

    §

    impl<'a, 'b> UnwindSafe for StrSearcher<'a, 'b>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ - T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ - T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ -
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ - U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │ +

    Struct alloc::str::pattern::StrSearcher

    source · 
    pub struct StrSearcher<'a, 'b> { /* private fields */ }
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    Associated type for <&str as Pattern<'a>>::Searcher.

    │ │ │ │ +

    Trait Implementations§

    source§

    impl<'a, 'b> Clone for StrSearcher<'a, 'b>

    source§

    fn clone(&self) -> StrSearcher<'a, 'b>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<'a, 'b> Debug for StrSearcher<'a, 'b>

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

    Formats the value using the given formatter. Read more
    source§

    impl<'a, 'b> ReverseSearcher<'a> for StrSearcher<'a, 'b>

    source§

    fn next_back(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back. Read more
    source§

    fn next_match_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. │ │ │ │ +See next_back().
    source§

    fn next_reject_back(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. │ │ │ │ +See next_back().
    source§

    impl<'a, 'b> Searcher<'a> for StrSearcher<'a, 'b>

    source§

    fn haystack(&self) -> &'a str

    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in Read more
    source§

    fn next(&mut self) -> SearchStep

    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front. Read more
    source§

    fn next_match(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next(). Read more
    source§

    fn next_reject(&mut self) -> Option<(usize, usize)>

    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next() │ │ │ │ +and next_match(). Read more

    Auto Trait Implementations§

    §

    impl<'a, 'b> Freeze for StrSearcher<'a, 'b>

    §

    impl<'a, 'b> RefUnwindSafe for StrSearcher<'a, 'b>

    §

    impl<'a, 'b> Send for StrSearcher<'a, 'b>

    §

    impl<'a, 'b> Sync for StrSearcher<'a, 'b>

    §

    impl<'a, 'b> Unpin for StrSearcher<'a, 'b>

    §

    impl<'a, 'b> UnwindSafe for StrSearcher<'a, 'b>

    Blanket Implementations§

    source§

    impl<T> Any for T
    where │ │ │ │ + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where │ │ │ │ + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    │ │ │ │ +
    source§

    impl<T, U> Into<U> for T
    where │ │ │ │ + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    │ │ │ │

    That is, this conversion is whatever the implementation of │ │ │ │ -From<T> for U chooses to do.

    │ │ │ │ +From<T> for U chooses to do.

    │ │ │ │
    source§

    impl<T> ToOwned for T
    where │ │ │ │ - T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ - U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ - U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ │ + T: Clone,
    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for T
    where │ │ │ │ + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for T
    where │ │ │ │ + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.DoubleEndedSearcher.html │ │ │ │ @@ -1,21 +1,21 @@ │ │ │ │ DoubleEndedSearcher in alloc::str::pattern - Rust
    │ │ │ │ -

    Trait alloc::str::pattern::DoubleEndedSearcher

    source · 
    pub trait DoubleEndedSearcher<'a>: ReverseSearcher<'a> { }
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    A marker trait to express that a ReverseSearcher │ │ │ │ -can be used for a DoubleEndedIterator implementation.

    │ │ │ │ +

    Trait alloc::str::pattern::DoubleEndedSearcher

    source · 
    pub trait DoubleEndedSearcher<'a>: ReverseSearcher<'a> { }
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description

    A marker trait to express that a ReverseSearcher │ │ │ │ +can be used for a DoubleEndedIterator implementation.

    │ │ │ │

    For this, the impl of Searcher and ReverseSearcher need │ │ │ │ to follow these conditions:

    │ │ │ │
      │ │ │ │
    • All results of next() need to be identical │ │ │ │ to the results of next_back() in reverse order.
      • │ │ │ │
    • next() and next_back() need to behave as │ │ │ │ the two ends of a range of values, that is they │ │ │ │ can not “walk past each other”.
      • │ │ │ │
    │ │ │ │

    §Examples

    │ │ │ │

    char::Searcher is a DoubleEndedSearcher because searching for a │ │ │ │ -char only requires looking at one at a time, which behaves the same │ │ │ │ +char only requires looking at one at a time, which behaves the same │ │ │ │ from both ends.

    │ │ │ │

    (&str)::Searcher is not a DoubleEndedSearcher because │ │ │ │ the pattern "aa" in the haystack "aaa" matches as either │ │ │ │ "[aa]a" or "a[aa]", depending from which side it is searched.

    │ │ │ │ -

    Implementors§

    source§

    impl<'a> DoubleEndedSearcher<'a> for CharSearcher<'a>

    source§

    impl<'a, 'b> DoubleEndedSearcher<'a> for CharSliceSearcher<'a, 'b>

    source§

    impl<'a, 'b, const N: usize> DoubleEndedSearcher<'a> for CharArrayRefSearcher<'a, 'b, N>

    source§

    impl<'a, F> DoubleEndedSearcher<'a> for CharPredicateSearcher<'a, F>
    where │ │ │ │ - F: FnMut(char) -> bool,

    source§

    impl<'a, const N: usize> DoubleEndedSearcher<'a> for CharArraySearcher<'a, N>

    │ │ │ │ +

    Implementors§

    source§

    impl<'a> DoubleEndedSearcher<'a> for CharSearcher<'a>

    source§

    impl<'a, 'b> DoubleEndedSearcher<'a> for CharSliceSearcher<'a, 'b>

    source§

    impl<'a, 'b, const N: usize> DoubleEndedSearcher<'a> for CharArrayRefSearcher<'a, 'b, N>

    source§

    impl<'a, F> DoubleEndedSearcher<'a> for CharPredicateSearcher<'a, F>
    where │ │ │ │ + F: FnMut(char) -> bool,

    source§

    impl<'a, const N: usize> DoubleEndedSearcher<'a> for CharArraySearcher<'a, N>

    │ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.Pattern.html │ │ │ │ @@ -1,32 +1,32 @@ │ │ │ │ Pattern in alloc::str::pattern - Rust
    │ │ │ │ -

    Trait alloc::str::pattern::Pattern

    source · 
    pub trait Pattern<'a>: Sized {
│ │ │ │ +    
    Trait alloc::str::pattern::Pattern
    source · 
    pub trait Pattern<'a>: Sized {
│ │ │ │      type Searcher: Searcher<'a>;
│ │ │ │  
│ │ │ │      // Required method
│ │ │ │ -    fn into_searcher(self, haystack: &'a str) -> Self::Searcher;
│ │ │ │ +    fn into_searcher(self, haystack: &'a str) -> Self::Searcher;
│ │ │ │  
│ │ │ │      // Provided methods
│ │ │ │ -    fn is_contained_in(self, haystack: &'a str) -> bool { ... }
│ │ │ │ -    fn is_prefix_of(self, haystack: &'a str) -> bool { ... }
│ │ │ │ -    fn is_suffix_of(self, haystack: &'a str) -> bool
│ │ │ │ +    fn is_contained_in(self, haystack: &'a str) -> bool { ... }
│ │ │ │ +    fn is_prefix_of(self, haystack: &'a str) -> bool { ... }
│ │ │ │ +    fn is_suffix_of(self, haystack: &'a str) -> bool
│ │ │ │         where Self::Searcher: ReverseSearcher<'a> { ... }
│ │ │ │ -    fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str> { ... }
│ │ │ │ -    fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
│ │ │ │ +    fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str> { ... }
│ │ │ │ +    fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
│ │ │ │         where Self::Searcher: ReverseSearcher<'a> { ... }
│ │ │ │  }
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description
    A string pattern.
    
│ │ │ │  
    A Pattern<'a> expresses that the implementing type
│ │ │ │ -can be used as a string pattern for searching in a &'a str.
    
│ │ │ │ +can be used as a string pattern for searching in a &'a str.
    
│ │ │ │  
    For example, both 'a' and "aa" are patterns that
│ │ │ │  would match at index 1 in the string "baaaab".
    
│ │ │ │  
    The trait itself acts as a builder for an associated
│ │ │ │  Searcher type, which does the actual work of finding
│ │ │ │  occurrences of the pattern in a string.
    
│ │ │ │  
    Depending on the type of the pattern, the behaviour of methods like
│ │ │ │ -str::find and str::contains can change. The table below describes
│ │ │ │ +str::find and str::contains can change. The table below describes
│ │ │ │  some of those behaviours.
    
│ │ │ │  
    
│ │ │ │  
│ │ │ │  
│ │ │ │  
│ │ │ │  
│ │ │ │  
│ │ │ │ @@ -51,47 +51,47 @@
│ │ │ │  assert_eq!("ab".find(&['b', 'a'][..]), Some(0));
│ │ │ │  assert_eq!("abaaa".find(&['a', 'z'][..]), Some(0));
│ │ │ │  assert_eq!("abaaa".find(&['c', 'd'][..]), None);
│ │ │ │  
│ │ │ │  // FnMut(char) -> bool
│ │ │ │  assert_eq!("abcdef_z".find(|ch| ch > 'd' && ch < 'y'), Some(4));
│ │ │ │  assert_eq!("abcddd_z".find(|ch| ch > 'd' && ch < 'y'), None);Run
│ │ │ │ -
    Required Associated Types§
    source
    type Searcher: Searcher<'a>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Associated searcher for this pattern
    
│ │ │ │ -
    Required Methods§
    source
    fn into_searcher(self, haystack: &'a str) -> Self::Searcher
    🔬This is a nightly-only experimental API. (pattern #27721)
    Constructs the associated searcher from
│ │ │ │ +
    Required Associated Types§
    source
    type Searcher: Searcher<'a>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Associated searcher for this pattern
    
│ │ │ │ +
    Required Methods§
    source
    fn into_searcher(self, haystack: &'a str) -> Self::Searcher
    🔬This is a nightly-only experimental API. (pattern #27721)
    Constructs the associated searcher from
│ │ │ │  self and the haystack to search in.
    
│ │ │ │ -
    Provided Methods§
    source
    fn is_contained_in(self, haystack: &'a str) -> bool
    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches anywhere in the haystack
    
│ │ │ │ -
    source
    fn is_prefix_of(self, haystack: &'a str) -> bool
    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches at the front of the haystack
    
│ │ │ │ -
    source
    fn is_suffix_of(self, haystack: &'a str) -> bool
    where
│ │ │ │ +
    Provided Methods§
    source
    fn is_contained_in(self, haystack: &'a str) -> bool
    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches anywhere in the haystack
    
│ │ │ │ +
    source
    fn is_prefix_of(self, haystack: &'a str) -> bool
    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches at the front of the haystack
    
│ │ │ │ +
    source
    fn is_suffix_of(self, haystack: &'a str) -> bool
    where
│ │ │ │      Self::Searcher: ReverseSearcher<'a>,
    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches at the back of the haystack
    
│ │ │ │ -
    source
    fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Removes the pattern from the front of haystack, if it matches.
    
│ │ │ │ -
    source
    fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
    where
│ │ │ │ +
    source
    fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Removes the pattern from the front of haystack, if it matches.
    
│ │ │ │ +
    source
    fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
    where
│ │ │ │      Self::Searcher: ReverseSearcher<'a>,
    🔬This is a nightly-only experimental API. (pattern #27721)
    Removes the pattern from the back of haystack, if it matches.
    
│ │ │ │ -
    Object Safety§
    This trait is not object safe.
    Implementors§
    source§
    impl<'a> Pattern<'a> for char
    Searches for chars that are equal to a given char.
    
│ │ │ │ +
    Object Safety§
    This trait is not object safe.
    Implementors§
    source§
    impl<'a> Pattern<'a> for char
    Searches for chars that are equal to a given char.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("Hello world".find('o'), Some(4));
    Run
    
│ │ │ │ -
    §
    type Searcher = CharSearcher<'a>
    source§
    impl<'a, 'b> Pattern<'a> for &'b str
    Non-allocating substring search.
    
│ │ │ │ +
    §
    type Searcher = CharSearcher<'a>
    source§
    impl<'a, 'b> Pattern<'a> for &'b str
    Non-allocating substring search.
    
│ │ │ │  
    Will handle the pattern "" as returning empty matches at each character
│ │ │ │  boundary.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("Hello world".find("world"), Some(6));
    Run
    
│ │ │ │  
    §
    type Searcher = StrSearcher<'a, 'b>
    source§
    impl<'a, 'b> Pattern<'a> for &'b String
    A convenience impl that delegates to the impl for &str.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!(String::from("Hello world").find("world"), Some(6));
    Run
    
│ │ │ │ -
    §
    type Searcher = <&'b str as Pattern<'a>>::Searcher
    source§
    impl<'a, 'b> Pattern<'a> for &'b [char]
    Searches for chars that are equal to any of the chars in the slice.
    
│ │ │ │ +
    §
    type Searcher = <&'b str as Pattern<'a>>::Searcher
    source§
    impl<'a, 'b> Pattern<'a> for &'b [char]
    Searches for chars that are equal to any of the chars in the slice.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("Hello world".find(&['l', 'l'] as &[_]), Some(2));
│ │ │ │  assert_eq!("Hello world".find(&['l', 'l'][..]), Some(2));
    Run
    
│ │ │ │ -
    §
    type Searcher = CharSliceSearcher<'a, 'b>
    source§
    impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str
    Delegates to the &str impl.
    
│ │ │ │ -
    §
    type Searcher = StrSearcher<'a, 'b>
    source§
    impl<'a, 'b, const N: usize> Pattern<'a> for &'b [char; N]
    Searches for chars that are equal to any of the chars in the array.
    
│ │ │ │ +
    §
    type Searcher = CharSliceSearcher<'a, 'b>
    source§
    impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str
    Delegates to the &str impl.
    
│ │ │ │ +
    §
    type Searcher = StrSearcher<'a, 'b>
    source§
    impl<'a, 'b, const N: usize> Pattern<'a> for &'b [char; N]
    Searches for chars that are equal to any of the chars in the array.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("Hello world".find(&['o', 'l']), Some(2));
│ │ │ │  assert_eq!("Hello world".find(&['h', 'w']), Some(6));
    Run
    
│ │ │ │ -
    §
    type Searcher = CharArrayRefSearcher<'a, 'b, N>
    source§
    impl<'a, F> Pattern<'a> for F
    where
│ │ │ │ -    F: FnMut(char) -> bool,
    Searches for chars that match the given predicate.
    
│ │ │ │ +
    §
    type Searcher = CharArrayRefSearcher<'a, 'b, N>
    source§
    impl<'a, F> Pattern<'a> for F
    where
│ │ │ │ +    F: FnMut(char) -> bool,
    Searches for chars that match the given predicate.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("Hello world".find(char::is_uppercase), Some(0));
│ │ │ │  assert_eq!("Hello world".find(|c| "aeiou".contains(c)), Some(1));
    Run
    
│ │ │ │ -
    §
    type Searcher = CharPredicateSearcher<'a, F>
    source§
    impl<'a, const N: usize> Pattern<'a> for [char; N]
    Searches for chars that are equal to any of the chars in the array.
    
│ │ │ │ +
    §
    type Searcher = CharPredicateSearcher<'a, F>
    source§
    impl<'a, const N: usize> Pattern<'a> for [char; N]
    Searches for chars that are equal to any of the chars in the array.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("Hello world".find(['o', 'l']), Some(2));
│ │ │ │  assert_eq!("Hello world".find(['h', 'w']), Some(6));
    Run
    
│ │ │ │  
    §
    type Searcher = CharArraySearcher<'a, N>
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.ReverseSearcher.html
│ │ │ │ @@ -1,26 +1,26 @@
│ │ │ │  ReverseSearcher in alloc::str::pattern - Rust
    
│ │ │ │ -    
    Trait alloc::str::pattern::ReverseSearcher
    source · 
    pub unsafe trait ReverseSearcher<'a>: Searcher<'a> {
│ │ │ │ +    
    Trait alloc::str::pattern::ReverseSearcher
    source · 
    pub unsafe trait ReverseSearcher<'a>: Searcher<'a> {
│ │ │ │      // Required method
│ │ │ │      fn next_back(&mut self) -> SearchStep;
│ │ │ │  
│ │ │ │      // Provided methods
│ │ │ │ -    fn next_match_back(&mut self) -> Option<(usize, usize)> { ... }
│ │ │ │ -    fn next_reject_back(&mut self) -> Option<(usize, usize)> { ... }
│ │ │ │ +    fn next_match_back(&mut self) -> Option<(usize, usize)> { ... }
│ │ │ │ +    fn next_reject_back(&mut self) -> Option<(usize, usize)> { ... }
│ │ │ │  }
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description
    A reverse searcher for a string pattern.
    
│ │ │ │  
    This trait provides methods for searching for non-overlapping
│ │ │ │  matches of a pattern starting from the back (right) of a string.
    
│ │ │ │  
    It will be implemented by associated Searcher
│ │ │ │  types of the Pattern trait if the pattern supports searching
│ │ │ │  for it from the back.
    
│ │ │ │  
    The index ranges returned by this trait are not required
│ │ │ │  to exactly match those of the forward search in reverse.
    
│ │ │ │  
    For the reason why this trait is marked unsafe, see the
│ │ │ │  parent trait Searcher.
    
│ │ │ │ -
    Required Methods§
    source
    fn next_back(&mut self) -> SearchStep
    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back.
    
│ │ │ │ +
    Required Methods§
    source
    fn next_back(&mut self) -> SearchStep
    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the back.
    
│ │ │ │  
      
│ │ │ │  
    • Returns Match(a, b) if haystack[a..b]
│ │ │ │  matches the pattern.
      • 
│ │ │ │  
    • Returns Reject(a, b) if haystack[a..b]
│ │ │ │  can not match the pattern, even partially.
      • 
│ │ │ │  
    • Returns Done if every byte of the haystack
│ │ │ │  has been visited
      • 
│ │ │ │ @@ -31,13 +31,13 @@
│ │ │ │  covering the whole haystack, and laying on utf8 boundaries.
      
│ │ │ │  
      A Match result needs to contain the whole matched
│ │ │ │  pattern, however Reject results may be split up
│ │ │ │  into arbitrary many adjacent fragments. Both ranges may have zero length.
      
│ │ │ │  
      As an example, the pattern "aaa" and the haystack "cbaaaaab"
│ │ │ │  might produce the stream
│ │ │ │  [Reject(7, 8), Match(4, 7), Reject(1, 4), Reject(0, 1)].
      
│ │ │ │ -
    Provided Methods§
    source
    fn next_match_back(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result.
│ │ │ │ +
    Provided Methods§
    source
    fn next_match_back(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result.
│ │ │ │  See next_back().
    
│ │ │ │ -
    source
    fn next_reject_back(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result.
│ │ │ │ +
    source
    fn next_reject_back(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result.
│ │ │ │  See next_back().
    
│ │ │ │ -
    Implementors§
    source§
    impl<'a> ReverseSearcher<'a> for CharSearcher<'a>
    source§
    impl<'a, 'b> ReverseSearcher<'a> for CharSliceSearcher<'a, 'b>
    source§
    impl<'a, 'b> ReverseSearcher<'a> for StrSearcher<'a, 'b>
    source§
    impl<'a, 'b, const N: usize> ReverseSearcher<'a> for CharArrayRefSearcher<'a, 'b, N>
    source§
    impl<'a, F> ReverseSearcher<'a> for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: FnMut(char) -> bool,
    source§
    impl<'a, const N: usize> ReverseSearcher<'a> for CharArraySearcher<'a, N>
    
│ │ │ │ +
    Implementors§
    source§
    impl<'a> ReverseSearcher<'a> for CharSearcher<'a>
    source§
    impl<'a, 'b> ReverseSearcher<'a> for CharSliceSearcher<'a, 'b>
    source§
    impl<'a, 'b> ReverseSearcher<'a> for StrSearcher<'a, 'b>
    source§
    impl<'a, 'b, const N: usize> ReverseSearcher<'a> for CharArrayRefSearcher<'a, 'b, N>
    source§
    impl<'a, F> ReverseSearcher<'a> for CharPredicateSearcher<'a, F>
    where
│ │ │ │ +    F: FnMut(char) -> bool,
    source§
    impl<'a, const N: usize> ReverseSearcher<'a> for CharArraySearcher<'a, N>
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/pattern/trait.Searcher.html
│ │ │ │ @@ -1,28 +1,28 @@
│ │ │ │  Searcher in alloc::str::pattern - Rust
    
│ │ │ │ -    
    Trait alloc::str::pattern::Searcher
    source · 
    pub unsafe trait Searcher<'a> {
│ │ │ │ +    
    Trait alloc::str::pattern::Searcher
    source · 
    pub unsafe trait Searcher<'a> {
│ │ │ │      // Required methods
│ │ │ │ -    fn haystack(&self) -> &'a str;
│ │ │ │ +    fn haystack(&self) -> &'a str;
│ │ │ │      fn next(&mut self) -> SearchStep;
│ │ │ │  
│ │ │ │      // Provided methods
│ │ │ │ -    fn next_match(&mut self) -> Option<(usize, usize)> { ... }
│ │ │ │ -    fn next_reject(&mut self) -> Option<(usize, usize)> { ... }
│ │ │ │ +    fn next_match(&mut self) -> Option<(usize, usize)> { ... }
│ │ │ │ +    fn next_reject(&mut self) -> Option<(usize, usize)> { ... }
│ │ │ │  }
    🔬This is a nightly-only experimental API. (pattern #27721)
    Expand description
    A searcher for a string pattern.
    
│ │ │ │  
    This trait provides methods for searching for non-overlapping
│ │ │ │  matches of a pattern starting from the front (left) of a string.
    
│ │ │ │  
    It will be implemented by associated Searcher
│ │ │ │  types of the Pattern trait.
    
│ │ │ │  
    The trait is marked unsafe because the indices returned by the
│ │ │ │  next() methods are required to lie on valid utf8
│ │ │ │  boundaries in the haystack. This enables consumers of this trait to
│ │ │ │  slice the haystack without additional runtime checks.
    
│ │ │ │ -
    Required Methods§
    source
    fn haystack(&self) -> &'a str
    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in
    
│ │ │ │ -
    Will always return the same &str.
    
│ │ │ │ -
    source
    fn next(&mut self) -> SearchStep
    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front.
    
│ │ │ │ +
    Required Methods§
    source
    fn haystack(&self) -> &'a str
    🔬This is a nightly-only experimental API. (pattern #27721)
    Getter for the underlying string to be searched in
    
│ │ │ │ +
    Will always return the same &str.
    
│ │ │ │ +
    source
    fn next(&mut self) -> SearchStep
    🔬This is a nightly-only experimental API. (pattern #27721)
    Performs the next search step starting from the front.
    
│ │ │ │  
      
│ │ │ │  
    • Returns Match(a, b) if haystack[a..b] matches
│ │ │ │  the pattern.
      • 
│ │ │ │  
    • Returns Reject(a, b) if haystack[a..b] can
│ │ │ │  not match the pattern, even partially.
      • 
│ │ │ │  
    • Returns Done if every byte of the haystack has
│ │ │ │  been visited.
      • 
│ │ │ │ @@ -33,18 +33,18 @@
│ │ │ │  covering the whole haystack, and laying on utf8 boundaries.
      
│ │ │ │  
      A Match result needs to contain the whole matched
│ │ │ │  pattern, however Reject results may be split up
│ │ │ │  into arbitrary many adjacent fragments. Both ranges may have zero length.
      
│ │ │ │  
      As an example, the pattern "aaa" and the haystack "cbaaaaab"
│ │ │ │  might produce the stream
│ │ │ │  [Reject(0, 1), Reject(1, 2), Match(2, 5), Reject(5, 8)]
      
│ │ │ │ -
    Provided Methods§
    source
    fn next_match(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next().
    
│ │ │ │ +
    Provided Methods§
    source
    fn next_match(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Match result. See next().
    
│ │ │ │  
    Unlike next(), there is no guarantee that the returned ranges
│ │ │ │  of this and next_reject will overlap. This will return
│ │ │ │  (start_match, end_match), where start_match is the index of where
│ │ │ │  the match begins, and end_match is the index after the end of the match.
    
│ │ │ │ -
    source
    fn next_reject(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next()
│ │ │ │ +
    source
    fn next_reject(&mut self) -> Option<(usize, usize)>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Finds the next Reject result. See next()
│ │ │ │  and next_match().
    
│ │ │ │  
    Unlike next(), there is no guarantee that the returned ranges
│ │ │ │  of this and next_match will overlap.
    
│ │ │ │ -
    Implementors§
    source§
    impl<'a> Searcher<'a> for CharSearcher<'a>
    source§
    impl<'a, 'b> Searcher<'a> for CharSliceSearcher<'a, 'b>
    source§
    impl<'a, 'b> Searcher<'a> for StrSearcher<'a, 'b>
    source§
    impl<'a, 'b, const N: usize> Searcher<'a> for CharArrayRefSearcher<'a, 'b, N>
    source§
    impl<'a, F> Searcher<'a> for CharPredicateSearcher<'a, F>
    where
│ │ │ │ -    F: FnMut(char) -> bool,
    source§
    impl<'a, const N: usize> Searcher<'a> for CharArraySearcher<'a, N>
    
│ │ │ │ +
    Implementors§
    source§
    impl<'a> Searcher<'a> for CharSearcher<'a>
    source§
    impl<'a, 'b> Searcher<'a> for CharSliceSearcher<'a, 'b>
    source§
    impl<'a, 'b> Searcher<'a> for StrSearcher<'a, 'b>
    source§
    impl<'a, 'b, const N: usize> Searcher<'a> for CharArrayRefSearcher<'a, 'b, N>
    source§
    impl<'a, F> Searcher<'a> for CharPredicateSearcher<'a, F>
    where
│ │ │ │ +    F: FnMut(char) -> bool,
    source§
    impl<'a, const N: usize> Searcher<'a> for CharArraySearcher<'a, N>
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Bytes.html
│ │ │ │ @@ -1,205 +1,205 @@
│ │ │ │  Bytes in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::Bytes
    1.0.0 · source · 
    pub struct Bytes<'a>(/* private fields */);
    Expand description
    An iterator over the bytes of a string slice.
    
│ │ │ │ -
    This struct is created by the bytes method on str.
│ │ │ │ +    
    Struct alloc::str::Bytes
    1.0.0 · source · 
    pub struct Bytes<'a>(/* private fields */);
    Expand description
    An iterator over the bytes of a string slice.
    
│ │ │ │ +
    This struct is created by the bytes method on str.
│ │ │ │  See its documentation for more.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for Bytes<'a>
    source§
    fn clone(&self) -> Bytes<'a> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for Bytes<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl DoubleEndedIterator for Bytes<'_>
    source§
    fn next_back(&mut self) -> Option<u8>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<<Bytes<'_> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn rfind<P>(&mut self, predicate: P) -> Option<<Bytes<'_> as Iterator>::Item>
    where
│ │ │ │ -    P: FnMut(&<Bytes<'_> as Iterator>::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    source§
    impl ExactSizeIterator for Bytes<'_>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl Iterator for Bytes<'_>
    §
    type Item = u8
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<u8>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<<Bytes<'_> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<Bytes<'_> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    F: FnMut(<Bytes<'_> as Iterator>::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    F: FnMut(<Bytes<'_> as Iterator>::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<<Bytes<'_> as Iterator>::Item>
    where
│ │ │ │ -    P: FnMut(&<Bytes<'_> as Iterator>::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    P: FnMut(<Bytes<'_> as Iterator>::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    P: FnMut(<Bytes<'_> as Iterator>::Item) -> bool,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ -index. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for Bytes<'a>
    source§
    fn clone(&self) -> Bytes<'a> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for Bytes<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl DoubleEndedIterator for Bytes<'_>
    source§
    fn next_back(&mut self) -> Option<u8>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn nth_back(&mut self, n: usize) -> Option<<Bytes<'_> as Iterator>::Item>
    Returns the nth element from the end of the iterator. Read more
    source§
    fn rfind<P>(&mut self, predicate: P) -> Option<<Bytes<'_> as Iterator>::Item>
    where
│ │ │ │ +    P: FnMut(&<Bytes<'_> as Iterator>::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    source§
    impl ExactSizeIterator for Bytes<'_>
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl Iterator for Bytes<'_>
    §
    type Item = u8
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<u8>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<<Bytes<'_> as Iterator>::Item>
    Consumes the iterator, returning the last element. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<<Bytes<'_> as Iterator>::Item>
    Returns the nth element of the iterator. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    F: FnMut(<Bytes<'_> as Iterator>::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    F: FnMut(<Bytes<'_> as Iterator>::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<<Bytes<'_> as Iterator>::Item>
    where
│ │ │ │ +    P: FnMut(&<Bytes<'_> as Iterator>::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    P: FnMut(<Bytes<'_> as Iterator>::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    P: FnMut(<Bytes<'_> as Iterator>::Item) -> bool,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ +index. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │  such that all those that return true precede all those that return false.
│ │ │ │ -Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ -    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ +    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl FusedIterator for Bytes<'_>
    source§
    impl TrustedLen for Bytes<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Bytes<'a>
    §
    impl<'a> RefUnwindSafe for Bytes<'a>
    §
    impl<'a> Send for Bytes<'a>
    §
    impl<'a> Sync for Bytes<'a>
    §
    impl<'a> Unpin for Bytes<'a>
    §
    impl<'a> UnwindSafe for Bytes<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl FusedIterator for Bytes<'_>
    source§
    impl TrustedLen for Bytes<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Bytes<'a>
    §
    impl<'a> RefUnwindSafe for Bytes<'a>
    §
    impl<'a> Send for Bytes<'a>
    §
    impl<'a> Sync for Bytes<'a>
    §
    impl<'a> Unpin for Bytes<'a>
    §
    impl<'a> UnwindSafe for Bytes<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.CharIndices.html
│ │ │ │ @@ -1,225 +1,225 @@
│ │ │ │  CharIndices in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::CharIndices
    1.0.0 · source · 
    pub struct CharIndices<'a> { /* private fields */ }
    Expand description
    An iterator over the chars of a string slice, and their positions.
    
│ │ │ │ -
    This struct is created by the char_indices method on str.
│ │ │ │ +    
    Struct alloc::str::CharIndices
    1.0.0 · source · 
    pub struct CharIndices<'a> { /* private fields */ }
    Expand description
    An iterator over the chars of a string slice, and their positions.
    
│ │ │ │ +
    This struct is created by the char_indices method on str.
│ │ │ │  See its documentation for more.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a> CharIndices<'a>
    1.4.0 · source
    pub fn as_str(&self) -> &'a str
    Views the underlying data as a subslice of the original data.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a> CharIndices<'a>
    1.4.0 · source
    pub fn as_str(&self) -> &'a str
    Views the underlying data as a subslice of the original data.
    
│ │ │ │  
    This has the same lifetime as the original slice, and so the
│ │ │ │  iterator can continue to be used while this exists.
    
│ │ │ │ -
    source
    pub fn offset(&self) -> usize
    🔬This is a nightly-only experimental API. (char_indices_offset #83871)
    Returns the byte position of the next character, or the length
│ │ │ │ +
    source
    pub fn offset(&self) -> usize
    🔬This is a nightly-only experimental API. (char_indices_offset #83871)
    Returns the byte position of the next character, or the length
│ │ │ │  of the underlying string if there are no more characters.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(char_indices_offset)]
│ │ │ │  let mut chars = "a楽".char_indices();
│ │ │ │  
│ │ │ │  assert_eq!(chars.offset(), 0);
│ │ │ │  assert_eq!(chars.next(), Some((0, 'a')));
│ │ │ │  
│ │ │ │  assert_eq!(chars.offset(), 1);
│ │ │ │  assert_eq!(chars.next(), Some((1, '楽')));
│ │ │ │  
│ │ │ │  assert_eq!(chars.offset(), 4);
│ │ │ │  assert_eq!(chars.next(), None);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for CharIndices<'a>
    source§
    fn clone(&self) -> CharIndices<'a> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for CharIndices<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for CharIndices<'a>
    source§
    fn next_back(&mut self) -> Option<(usize, char)>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for CharIndices<'a>
    §
    type Item = (usize, char)
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<(usize, char)>
    Advances the iterator and returns the next value. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<(usize, char)>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for CharIndices<'a>
    source§
    fn clone(&self) -> CharIndices<'a> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for CharIndices<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for CharIndices<'a>
    source§
    fn next_back(&mut self) -> Option<(usize, char)>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for CharIndices<'a>
    §
    type Item = (usize, char)
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<(usize, char)>
    Advances the iterator and returns the next value. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<(usize, char)>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │  such that all those that return true precede all those that return false.
│ │ │ │ -Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ -    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ +    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl FusedIterator for CharIndices<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for CharIndices<'a>
    §
    impl<'a> RefUnwindSafe for CharIndices<'a>
    §
    impl<'a> Send for CharIndices<'a>
    §
    impl<'a> Sync for CharIndices<'a>
    §
    impl<'a> Unpin for CharIndices<'a>
    §
    impl<'a> UnwindSafe for CharIndices<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl FusedIterator for CharIndices<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for CharIndices<'a>
    §
    impl<'a> RefUnwindSafe for CharIndices<'a>
    §
    impl<'a> Send for CharIndices<'a>
    §
    impl<'a> Sync for CharIndices<'a>
    §
    impl<'a> Unpin for CharIndices<'a>
    §
    impl<'a> UnwindSafe for CharIndices<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Chars.html
│ │ │ │ @@ -1,220 +1,220 @@
│ │ │ │  Chars in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::Chars
    1.0.0 · source · 
    pub struct Chars<'a> { /* private fields */ }
    Expand description
    An iterator over the chars of a string slice.
    
│ │ │ │ -
    This struct is created by the chars method on str.
│ │ │ │ +    
    Struct alloc::str::Chars
    1.0.0 · source · 
    pub struct Chars<'a> { /* private fields */ }
    Expand description
    An iterator over the chars of a string slice.
    
│ │ │ │ +
    This struct is created by the chars method on str.
│ │ │ │  See its documentation for more.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a> Chars<'a>
    1.4.0 · source
    pub fn as_str(&self) -> &'a str
    Views the underlying data as a subslice of the original data.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a> Chars<'a>
    1.4.0 · source
    pub fn as_str(&self) -> &'a str
    Views the underlying data as a subslice of the original data.
    
│ │ │ │  
    This has the same lifetime as the original slice, and so the
│ │ │ │  iterator can continue to be used while this exists.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut chars = "abc".chars();
│ │ │ │  
│ │ │ │  assert_eq!(chars.as_str(), "abc");
│ │ │ │  chars.next();
│ │ │ │  assert_eq!(chars.as_str(), "bc");
│ │ │ │  chars.next();
│ │ │ │  chars.next();
│ │ │ │  assert_eq!(chars.as_str(), "");
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for Chars<'a>
    source§
    fn clone(&self) -> Chars<'a> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    1.38.0 · source§
    impl Debug for Chars<'_>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for Chars<'a>
    source§
    fn next_back(&mut self) -> Option<char>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for Chars<'a>
    §
    type Item = char
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<char>
    Advances the iterator and returns the next value. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, remainder: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<char>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for Chars<'a>
    source§
    fn clone(&self) -> Chars<'a> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    1.38.0 · source§
    impl Debug for Chars<'_>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for Chars<'a>
    source§
    fn next_back(&mut self) -> Option<char>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for Chars<'a>
    §
    type Item = char
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<char>
    Advances the iterator and returns the next value. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, remainder: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<char>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │  such that all those that return true precede all those that return false.
│ │ │ │ -Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ -    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ +    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl FusedIterator for Chars<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Chars<'a>
    §
    impl<'a> RefUnwindSafe for Chars<'a>
    §
    impl<'a> Send for Chars<'a>
    §
    impl<'a> Sync for Chars<'a>
    §
    impl<'a> Unpin for Chars<'a>
    §
    impl<'a> UnwindSafe for Chars<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl FusedIterator for Chars<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Chars<'a>
    §
    impl<'a> RefUnwindSafe for Chars<'a>
    §
    impl<'a> Send for Chars<'a>
    §
    impl<'a> Sync for Chars<'a>
    §
    impl<'a> Unpin for Chars<'a>
    §
    impl<'a> UnwindSafe for Chars<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EncodeUtf16.html
│ │ │ │ @@ -1,195 +1,195 @@
│ │ │ │  EncodeUtf16 in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::EncodeUtf16
    1.8.0 · source · 
    pub struct EncodeUtf16<'a> { /* private fields */ }
    Expand description
    An iterator of u16 over the string encoded as UTF-16.
    
│ │ │ │ -
    This struct is created by the encode_utf16 method on str.
│ │ │ │ +    
    Struct alloc::str::EncodeUtf16
    1.8.0 · source · 
    pub struct EncodeUtf16<'a> { /* private fields */ }
    Expand description
    An iterator of u16 over the string encoded as UTF-16.
    
│ │ │ │ +
    This struct is created by the encode_utf16 method on str.
│ │ │ │  See its documentation for more.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for EncodeUtf16<'a>
    source§
    fn clone(&self) -> EncodeUtf16<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    1.17.0 · source§
    impl Debug for EncodeUtf16<'_>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Iterator for EncodeUtf16<'a>
    §
    type Item = u16
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<u16>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for EncodeUtf16<'a>
    source§
    fn clone(&self) -> EncodeUtf16<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    1.17.0 · source§
    impl Debug for EncodeUtf16<'_>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Iterator for EncodeUtf16<'a>
    §
    type Item = u16
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<u16>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl FusedIterator for EncodeUtf16<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for EncodeUtf16<'a>
    §
    impl<'a> RefUnwindSafe for EncodeUtf16<'a>
    §
    impl<'a> Send for EncodeUtf16<'a>
    §
    impl<'a> Sync for EncodeUtf16<'a>
    §
    impl<'a> Unpin for EncodeUtf16<'a>
    §
    impl<'a> UnwindSafe for EncodeUtf16<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl FusedIterator for EncodeUtf16<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for EncodeUtf16<'a>
    §
    impl<'a> RefUnwindSafe for EncodeUtf16<'a>
    §
    impl<'a> Send for EncodeUtf16<'a>
    §
    impl<'a> Sync for EncodeUtf16<'a>
    §
    impl<'a> Unpin for EncodeUtf16<'a>
    §
    impl<'a> UnwindSafe for EncodeUtf16<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EscapeDebug.html
│ │ │ │ @@ -1,193 +1,193 @@
│ │ │ │  EscapeDebug in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::EscapeDebug
    1.34.0 · source · 
    pub struct EscapeDebug<'a> { /* private fields */ }
    Expand description
    The return type of str::escape_debug.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for EscapeDebug<'a>
    source§
    fn clone(&self) -> EscapeDebug<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for EscapeDebug<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Display for EscapeDebug<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Iterator for EscapeDebug<'a>
    §
    type Item = char
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<char>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
    where
│ │ │ │ -    EscapeDebug<'a>: Sized,
│ │ │ │ -    Fold: FnMut(Acc, <EscapeDebug<'a> as Iterator>::Item) -> R,
│ │ │ │ -    R: Try<Output = Acc>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    source§
    fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
    where
│ │ │ │ -    Fold: FnMut(Acc, <EscapeDebug<'a> as Iterator>::Item) -> Acc,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    
    Struct alloc::str::EscapeDebug
    1.34.0 · source · 
    pub struct EscapeDebug<'a> { /* private fields */ }
    Expand description
    The return type of str::escape_debug.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for EscapeDebug<'a>
    source§
    fn clone(&self) -> EscapeDebug<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for EscapeDebug<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Display for EscapeDebug<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Iterator for EscapeDebug<'a>
    §
    type Item = char
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<char>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
    where
│ │ │ │ +    EscapeDebug<'a>: Sized,
│ │ │ │ +    Fold: FnMut(Acc, <EscapeDebug<'a> as Iterator>::Item) -> R,
│ │ │ │ +    R: Try<Output = Acc>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    source§
    fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
    where
│ │ │ │ +    Fold: FnMut(Acc, <EscapeDebug<'a> as Iterator>::Item) -> Acc,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    source§
    impl<'a> FusedIterator for EscapeDebug<'a>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for EscapeDebug<'a>
    §
    impl<'a> RefUnwindSafe for EscapeDebug<'a>
    §
    impl<'a> Send for EscapeDebug<'a>
    §
    impl<'a> Sync for EscapeDebug<'a>
    §
    impl<'a> Unpin for EscapeDebug<'a>
    §
    impl<'a> UnwindSafe for EscapeDebug<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    source§
    impl<'a> FusedIterator for EscapeDebug<'a>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for EscapeDebug<'a>
    §
    impl<'a> RefUnwindSafe for EscapeDebug<'a>
    §
    impl<'a> Send for EscapeDebug<'a>
    §
    impl<'a> Sync for EscapeDebug<'a>
    §
    impl<'a> Unpin for EscapeDebug<'a>
    §
    impl<'a> UnwindSafe for EscapeDebug<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ -    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ +    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EscapeDefault.html
│ │ │ │ @@ -1,193 +1,193 @@
│ │ │ │  EscapeDefault in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::EscapeDefault
    1.34.0 · source · 
    pub struct EscapeDefault<'a> { /* private fields */ }
    Expand description
    The return type of str::escape_default.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for EscapeDefault<'a>
    source§
    fn clone(&self) -> EscapeDefault<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for EscapeDefault<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Display for EscapeDefault<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Iterator for EscapeDefault<'a>
    §
    type Item = char
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<char>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
    where
│ │ │ │ -    EscapeDefault<'a>: Sized,
│ │ │ │ -    Fold: FnMut(Acc, <EscapeDefault<'a> as Iterator>::Item) -> R,
│ │ │ │ -    R: Try<Output = Acc>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    source§
    fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
    where
│ │ │ │ -    Fold: FnMut(Acc, <EscapeDefault<'a> as Iterator>::Item) -> Acc,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    
    Struct alloc::str::EscapeDefault
    1.34.0 · source · 
    pub struct EscapeDefault<'a> { /* private fields */ }
    Expand description
    The return type of str::escape_default.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for EscapeDefault<'a>
    source§
    fn clone(&self) -> EscapeDefault<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for EscapeDefault<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Display for EscapeDefault<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Iterator for EscapeDefault<'a>
    §
    type Item = char
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<char>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
    where
│ │ │ │ +    EscapeDefault<'a>: Sized,
│ │ │ │ +    Fold: FnMut(Acc, <EscapeDefault<'a> as Iterator>::Item) -> R,
│ │ │ │ +    R: Try<Output = Acc>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    source§
    fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
    where
│ │ │ │ +    Fold: FnMut(Acc, <EscapeDefault<'a> as Iterator>::Item) -> Acc,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    source§
    impl<'a> FusedIterator for EscapeDefault<'a>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for EscapeDefault<'a>
    §
    impl<'a> RefUnwindSafe for EscapeDefault<'a>
    §
    impl<'a> Send for EscapeDefault<'a>
    §
    impl<'a> Sync for EscapeDefault<'a>
    §
    impl<'a> Unpin for EscapeDefault<'a>
    §
    impl<'a> UnwindSafe for EscapeDefault<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    source§
    impl<'a> FusedIterator for EscapeDefault<'a>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for EscapeDefault<'a>
    §
    impl<'a> RefUnwindSafe for EscapeDefault<'a>
    §
    impl<'a> Send for EscapeDefault<'a>
    §
    impl<'a> Sync for EscapeDefault<'a>
    §
    impl<'a> Unpin for EscapeDefault<'a>
    §
    impl<'a> UnwindSafe for EscapeDefault<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ -    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ +    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.EscapeUnicode.html
│ │ │ │ @@ -1,193 +1,193 @@
│ │ │ │  EscapeUnicode in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::EscapeUnicode
    1.34.0 · source · 
    pub struct EscapeUnicode<'a> { /* private fields */ }
    Expand description
    The return type of str::escape_unicode.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for EscapeUnicode<'a>
    source§
    fn clone(&self) -> EscapeUnicode<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for EscapeUnicode<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Display for EscapeUnicode<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Iterator for EscapeUnicode<'a>
    §
    type Item = char
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<char>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
    where
│ │ │ │ -    EscapeUnicode<'a>: Sized,
│ │ │ │ -    Fold: FnMut(Acc, <EscapeUnicode<'a> as Iterator>::Item) -> R,
│ │ │ │ -    R: Try<Output = Acc>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    source§
    fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
    where
│ │ │ │ -    Fold: FnMut(Acc, <EscapeUnicode<'a> as Iterator>::Item) -> Acc,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    
    Struct alloc::str::EscapeUnicode
    1.34.0 · source · 
    pub struct EscapeUnicode<'a> { /* private fields */ }
    Expand description
    The return type of str::escape_unicode.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for EscapeUnicode<'a>
    source§
    fn clone(&self) -> EscapeUnicode<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for EscapeUnicode<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Display for EscapeUnicode<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Iterator for EscapeUnicode<'a>
    §
    type Item = char
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<char>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
    where
│ │ │ │ +    EscapeUnicode<'a>: Sized,
│ │ │ │ +    Fold: FnMut(Acc, <EscapeUnicode<'a> as Iterator>::Item) -> R,
│ │ │ │ +    R: Try<Output = Acc>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    source§
    fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
    where
│ │ │ │ +    Fold: FnMut(Acc, <EscapeUnicode<'a> as Iterator>::Item) -> Acc,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    source§
    impl<'a> FusedIterator for EscapeUnicode<'a>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for EscapeUnicode<'a>
    §
    impl<'a> RefUnwindSafe for EscapeUnicode<'a>
    §
    impl<'a> Send for EscapeUnicode<'a>
    §
    impl<'a> Sync for EscapeUnicode<'a>
    §
    impl<'a> Unpin for EscapeUnicode<'a>
    §
    impl<'a> UnwindSafe for EscapeUnicode<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    source§
    impl<'a> FusedIterator for EscapeUnicode<'a>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for EscapeUnicode<'a>
    §
    impl<'a> RefUnwindSafe for EscapeUnicode<'a>
    §
    impl<'a> Send for EscapeUnicode<'a>
    §
    impl<'a> Sync for EscapeUnicode<'a>
    §
    impl<'a> Unpin for EscapeUnicode<'a>
    §
    impl<'a> UnwindSafe for EscapeUnicode<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ -    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ +    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Lines.html
│ │ │ │ @@ -1,221 +1,221 @@
│ │ │ │  Lines in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::Lines
    1.0.0 · source · 
    pub struct Lines<'a>(/* private fields */);
    Expand description
    An iterator over the lines of a string, as string slices.
    
│ │ │ │ -
    This struct is created with the lines method on str.
│ │ │ │ +    
    Struct alloc::str::Lines
    1.0.0 · source · 
    pub struct Lines<'a>(/* private fields */);
    Expand description
    An iterator over the lines of a string, as string slices.
    
│ │ │ │ +
    This struct is created with the lines method on str.
│ │ │ │  See its documentation for more.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a> Lines<'a>
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_lines_remainder #77998)
    Returns the remaining lines of the split string.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a> Lines<'a>
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_lines_remainder #77998)
    Returns the remaining lines of the split string.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(str_lines_remainder)]
│ │ │ │  
│ │ │ │  let mut lines = "a\nb\nc\nd".lines();
│ │ │ │  assert_eq!(lines.remainder(), Some("a\nb\nc\nd"));
│ │ │ │  
│ │ │ │  lines.next();
│ │ │ │  assert_eq!(lines.remainder(), Some("b\nc\nd"));
│ │ │ │  
│ │ │ │  lines.by_ref().for_each(drop);
│ │ │ │  assert_eq!(lines.remainder(), None);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for Lines<'a>
    source§
    fn clone(&self) -> Lines<'a> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for Lines<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for Lines<'a>
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for Lines<'a>
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<&'a str>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for Lines<'a>
    source§
    fn clone(&self) -> Lines<'a> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for Lines<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for Lines<'a>
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for Lines<'a>
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<&'a str>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │  such that all those that return true precede all those that return false.
│ │ │ │ -Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ -    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ +    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl FusedIterator for Lines<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Lines<'a>
    §
    impl<'a> RefUnwindSafe for Lines<'a>
    §
    impl<'a> Send for Lines<'a>
    §
    impl<'a> Sync for Lines<'a>
    §
    impl<'a> Unpin for Lines<'a>
    §
    impl<'a> UnwindSafe for Lines<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl FusedIterator for Lines<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Lines<'a>
    §
    impl<'a> RefUnwindSafe for Lines<'a>
    §
    impl<'a> Send for Lines<'a>
    §
    impl<'a> Sync for Lines<'a>
    §
    impl<'a> Unpin for Lines<'a>
    §
    impl<'a> UnwindSafe for Lines<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.LinesAny.html
│ │ │ │ @@ -1,208 +1,208 @@
│ │ │ │  LinesAny in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::LinesAny
    1.0.0 · source · 
    pub struct LinesAny<'a>(/* private fields */);
    👎Deprecated since 1.4.0: use lines()/Lines instead now
    Expand description
    Created with the method lines_any.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for LinesAny<'a>
    source§
    fn clone(&self) -> LinesAny<'a> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for LinesAny<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for LinesAny<'a>
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for LinesAny<'a>
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    
    Struct alloc::str::LinesAny
    1.0.0 · source · 
    pub struct LinesAny<'a>(/* private fields */);
    👎Deprecated since 1.4.0: use lines()/Lines instead now
    Expand description
    Created with the method lines_any.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for LinesAny<'a>
    source§
    fn clone(&self) -> LinesAny<'a> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for LinesAny<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for LinesAny<'a>
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for LinesAny<'a>
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │  such that all those that return true precede all those that return false.
│ │ │ │ -Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ -    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ +    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl FusedIterator for LinesAny<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for LinesAny<'a>
    §
    impl<'a> RefUnwindSafe for LinesAny<'a>
    §
    impl<'a> Send for LinesAny<'a>
    §
    impl<'a> Sync for LinesAny<'a>
    §
    impl<'a> Unpin for LinesAny<'a>
    §
    impl<'a> UnwindSafe for LinesAny<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl FusedIterator for LinesAny<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for LinesAny<'a>
    §
    impl<'a> RefUnwindSafe for LinesAny<'a>
    §
    impl<'a> Send for LinesAny<'a>
    §
    impl<'a> Sync for LinesAny<'a>
    §
    impl<'a> Unpin for LinesAny<'a>
    §
    impl<'a> UnwindSafe for LinesAny<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.MatchIndices.html
│ │ │ │ @@ -1,217 +1,217 @@
│ │ │ │  MatchIndices in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::MatchIndices
    1.5.0 · source · 
    pub struct MatchIndices<'a, P>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::MatchIndices
    1.5.0 · source · 
    pub struct MatchIndices<'a, P>(/* private fields */)
│ │ │ │  where
│ │ │ │ -    P: Pattern<'a>;
    Expand description
    Created with the method match_indices.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, P> Clone for MatchIndices<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>;
    Expand description
    Created with the method match_indices.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, P> Clone for MatchIndices<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> MatchIndices<'a, P> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for MatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> MatchIndices<'a, P> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for MatchIndices<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for MatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for MatchIndices<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<(usize, &'a str)>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for MatchIndices<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    §
    type Item = (usize, &'a str)
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<(usize, &'a str)>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<(usize, &'a str)>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for MatchIndices<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    §
    type Item = (usize, &'a str)
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<(usize, &'a str)>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for MatchIndices<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for MatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for MatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for MatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for MatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for MatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for MatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for MatchIndices<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for MatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for MatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for MatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for MatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for MatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for MatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Matches.html
│ │ │ │ @@ -1,217 +1,217 @@
│ │ │ │  Matches in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::Matches
    1.2.0 · source · 
    pub struct Matches<'a, P>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::Matches
    1.2.0 · source · 
    pub struct Matches<'a, P>(/* private fields */)
│ │ │ │  where
│ │ │ │ -    P: Pattern<'a>;
    Expand description
    Created with the method matches.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, P> Clone for Matches<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>;
    Expand description
    Created with the method matches.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, P> Clone for Matches<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> Matches<'a, P> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for Matches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> Matches<'a, P> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for Matches<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for Matches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for Matches<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for Matches<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for Matches<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for Matches<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for Matches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for Matches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for Matches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for Matches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for Matches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for Matches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for Matches<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for Matches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for Matches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for Matches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for Matches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for Matches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for Matches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.ParseBoolError.html
│ │ │ │ @@ -1,17 +1,17 @@
│ │ │ │  ParseBoolError in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::ParseBoolError
    1.0.0 · source · 
    #[non_exhaustive]
    pub struct ParseBoolError;
    Expand description
    An error returned when parsing a bool using from_str fails
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl Clone for ParseBoolError
    source§
    fn clone(&self) -> ParseBoolError
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for ParseBoolError
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl Display for ParseBoolError
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl Error for ParseBoolError
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    1.30.0 · source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn provide<'a>(&'a self, request: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§
    impl PartialEq for ParseBoolError
    source§
    fn eq(&self, other: &ParseBoolError) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl Eq for ParseBoolError
    source§
    impl StructuralPartialEq for ParseBoolError
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +    
    Struct alloc::str::ParseBoolError
    1.0.0 · source · 
    #[non_exhaustive]
    pub struct ParseBoolError;
    Expand description
    An error returned when parsing a bool using from_str fails
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl Clone for ParseBoolError
    source§
    fn clone(&self) -> ParseBoolError
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for ParseBoolError
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl Display for ParseBoolError
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl Error for ParseBoolError
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    1.30.0 · source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn provide<'a>(&'a self, request: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§
    impl PartialEq for ParseBoolError
    source§
    fn eq(&self, other: &ParseBoolError) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl Eq for ParseBoolError
    source§
    impl StructuralPartialEq for ParseBoolError
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │  
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ -    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ +    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RMatchIndices.html
│ │ │ │ @@ -1,219 +1,219 @@
│ │ │ │  RMatchIndices in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::RMatchIndices
    1.5.0 · source · 
    pub struct RMatchIndices<'a, P>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::RMatchIndices
    1.5.0 · source · 
    pub struct RMatchIndices<'a, P>(/* private fields */)
│ │ │ │  where
│ │ │ │ -    P: Pattern<'a>;
    Expand description
    Created with the method rmatch_indices.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, P> Clone for RMatchIndices<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>;
    Expand description
    Created with the method rmatch_indices.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, P> Clone for RMatchIndices<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> RMatchIndices<'a, P> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for RMatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> RMatchIndices<'a, P> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for RMatchIndices<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for RMatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for RMatchIndices<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<(usize, &'a str)>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for RMatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<(usize, &'a str)>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for RMatchIndices<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    §
    type Item = (usize, &'a str)
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<(usize, &'a str)>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    §
    type Item = (usize, &'a str)
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<(usize, &'a str)>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for RMatchIndices<'a, P>
    where
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for RMatchIndices<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for RMatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for RMatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for RMatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for RMatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for RMatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for RMatchIndices<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for RMatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for RMatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for RMatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for RMatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for RMatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for RMatchIndices<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RMatches.html
│ │ │ │ @@ -1,219 +1,219 @@
│ │ │ │  RMatches in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::RMatches
    1.2.0 · source · 
    pub struct RMatches<'a, P>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::RMatches
    1.2.0 · source · 
    pub struct RMatches<'a, P>(/* private fields */)
│ │ │ │  where
│ │ │ │ -    P: Pattern<'a>;
    Expand description
    Created with the method rmatches.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, P> Clone for RMatches<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>;
    Expand description
    Created with the method rmatches.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, P> Clone for RMatches<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> RMatches<'a, P> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for RMatches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> RMatches<'a, P> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for RMatches<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for RMatches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for RMatches<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for RMatches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for RMatches<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for RMatches<'a, P>
    where
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for RMatches<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for RMatches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for RMatches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for RMatches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for RMatches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for RMatches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for RMatches<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for RMatches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for RMatches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for RMatches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for RMatches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for RMatches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for RMatches<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RSplit.html
│ │ │ │ @@ -1,230 +1,230 @@
│ │ │ │  RSplit in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::RSplit
    1.0.0 · source · 
    pub struct RSplit<'a, P>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::RSplit
    1.0.0 · source · 
    pub struct RSplit<'a, P>(/* private fields */)
│ │ │ │  where
│ │ │ │ -    P: Pattern<'a>;
    Expand description
    Created with the method rsplit.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, P> RSplit<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │ +    P: Pattern<'a>;
    Expand description
    Created with the method rsplit.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, P> RSplit<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │  
    If the iterator is empty, returns None.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(str_split_remainder)]
│ │ │ │  let mut split = "Mary had a little lamb".rsplit(' ');
│ │ │ │  assert_eq!(split.remainder(), Some("Mary had a little lamb"));
│ │ │ │  split.next();
│ │ │ │  assert_eq!(split.remainder(), Some("Mary had a little"));
│ │ │ │  split.by_ref().for_each(drop);
│ │ │ │  assert_eq!(split.remainder(), None);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, P> Clone for RSplit<'a, P>
    where
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, P> Clone for RSplit<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> RSplit<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for RSplit<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> RSplit<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for RSplit<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for RSplit<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for RSplit<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for RSplit<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for RSplit<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for RSplit<'a, P>
    where
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for RSplit<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for RSplit<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for RSplit<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for RSplit<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for RSplit<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for RSplit<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for RSplit<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for RSplit<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for RSplit<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for RSplit<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for RSplit<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for RSplit<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for RSplit<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RSplitN.html
│ │ │ │ @@ -1,219 +1,219 @@
│ │ │ │  RSplitN in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::RSplitN
    1.0.0 · source · 
    pub struct RSplitN<'a, P>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::RSplitN
    1.0.0 · source · 
    pub struct RSplitN<'a, P>(/* private fields */)
│ │ │ │  where
│ │ │ │ -    P: Pattern<'a>;
    Expand description
    Created with the method rsplitn.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, P> RSplitN<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │ +    P: Pattern<'a>;
    Expand description
    Created with the method rsplitn.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, P> RSplitN<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │  
    If the iterator is empty, returns None.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(str_split_remainder)]
│ │ │ │  let mut split = "Mary had a little lamb".rsplitn(3, ' ');
│ │ │ │  assert_eq!(split.remainder(), Some("Mary had a little lamb"));
│ │ │ │  split.next();
│ │ │ │  assert_eq!(split.remainder(), Some("Mary had a little"));
│ │ │ │  split.by_ref().for_each(drop);
│ │ │ │  assert_eq!(split.remainder(), None);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, P> Clone for RSplitN<'a, P>
    where
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, P> Clone for RSplitN<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> RSplitN<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for RSplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> RSplitN<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for RSplitN<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> Iterator for RSplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> Iterator for RSplitN<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for RSplitN<'a, P>
    where
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for RSplitN<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for RSplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for RSplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for RSplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for RSplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for RSplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for RSplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for RSplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for RSplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for RSplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for RSplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for RSplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for RSplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.RSplitTerminator.html
│ │ │ │ @@ -1,230 +1,230 @@
│ │ │ │  RSplitTerminator in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::RSplitTerminator
    1.0.0 · source · 
    pub struct RSplitTerminator<'a, P>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::RSplitTerminator
    1.0.0 · source · 
    pub struct RSplitTerminator<'a, P>(/* private fields */)
│ │ │ │  where
│ │ │ │ -    P: Pattern<'a>;
    Expand description
    Created with the method rsplit_terminator.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, P> RSplitTerminator<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │ +    P: Pattern<'a>;
    Expand description
    Created with the method rsplit_terminator.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, P> RSplitTerminator<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │  
    If the iterator is empty, returns None.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(str_split_remainder)]
│ │ │ │  let mut split = "A..B..".rsplit_terminator('.');
│ │ │ │  assert_eq!(split.remainder(), Some("A..B.."));
│ │ │ │  split.next();
│ │ │ │  assert_eq!(split.remainder(), Some("A..B"));
│ │ │ │  split.by_ref().for_each(drop);
│ │ │ │  assert_eq!(split.remainder(), None);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, P> Clone for RSplitTerminator<'a, P>
    where
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, P> Clone for RSplitTerminator<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> RSplitTerminator<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for RSplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> RSplitTerminator<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for RSplitTerminator<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for RSplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for RSplitTerminator<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for RSplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for RSplitTerminator<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for RSplitTerminator<'a, P>
    where
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for RSplitTerminator<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for RSplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for RSplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for RSplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for RSplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for RSplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for RSplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for RSplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for RSplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for RSplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for RSplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for RSplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for RSplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Split.html
│ │ │ │ @@ -1,228 +1,228 @@
│ │ │ │  Split in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::Split
    1.0.0 · source · 
    pub struct Split<'a, P>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::Split
    1.0.0 · source · 
    pub struct Split<'a, P>(/* private fields */)
│ │ │ │  where
│ │ │ │ -    P: Pattern<'a>;
    Expand description
    Created with the method split.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, P> Split<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │ +    P: Pattern<'a>;
    Expand description
    Created with the method split.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, P> Split<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │  
    If the iterator is empty, returns None.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(str_split_remainder)]
│ │ │ │  let mut split = "Mary had a little lamb".split(' ');
│ │ │ │  assert_eq!(split.remainder(), Some("Mary had a little lamb"));
│ │ │ │  split.next();
│ │ │ │  assert_eq!(split.remainder(), Some("had a little lamb"));
│ │ │ │  split.by_ref().for_each(drop);
│ │ │ │  assert_eq!(split.remainder(), None);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, P> Clone for Split<'a, P>
    where
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, P> Clone for Split<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> Split<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for Split<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> Split<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for Split<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for Split<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for Split<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for Split<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for Split<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for Split<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for Split<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for Split<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for Split<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for Split<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for Split<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for Split<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for Split<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for Split<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for Split<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for Split<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for Split<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for Split<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for Split<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitAsciiWhitespace.html
│ │ │ │ @@ -1,223 +1,223 @@
│ │ │ │  SplitAsciiWhitespace in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::SplitAsciiWhitespace
    1.34.0 · source · 
    pub struct SplitAsciiWhitespace<'a> { /* private fields */ }
    Expand description
    An iterator over the non-ASCII-whitespace substrings of a string,
│ │ │ │ +    
    Struct alloc::str::SplitAsciiWhitespace
    1.34.0 · source · 
    pub struct SplitAsciiWhitespace<'a> { /* private fields */ }
    Expand description
    An iterator over the non-ASCII-whitespace substrings of a string,
│ │ │ │  separated by any amount of ASCII whitespace.
    
│ │ │ │ -
    This struct is created by the split_ascii_whitespace method on str.
│ │ │ │ +
    This struct is created by the split_ascii_whitespace method on str.
│ │ │ │  See its documentation for more.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a> SplitAsciiWhitespace<'a>
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_whitespace_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a> SplitAsciiWhitespace<'a>
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_whitespace_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │  
    If the iterator is empty, returns None.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(str_split_whitespace_remainder)]
│ │ │ │  
│ │ │ │  let mut split = "Mary had a little lamb".split_ascii_whitespace();
│ │ │ │  assert_eq!(split.remainder(), Some("Mary had a little lamb"));
│ │ │ │  
│ │ │ │  split.next();
│ │ │ │  assert_eq!(split.remainder(), Some("had a little lamb"));
│ │ │ │  
│ │ │ │  split.by_ref().for_each(drop);
│ │ │ │  assert_eq!(split.remainder(), None);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for SplitAsciiWhitespace<'a>
    source§
    fn clone(&self) -> SplitAsciiWhitespace<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for SplitAsciiWhitespace<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for SplitAsciiWhitespace<'a>
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for SplitAsciiWhitespace<'a>
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<&'a str>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for SplitAsciiWhitespace<'a>
    source§
    fn clone(&self) -> SplitAsciiWhitespace<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for SplitAsciiWhitespace<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for SplitAsciiWhitespace<'a>
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for SplitAsciiWhitespace<'a>
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<&'a str>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │  such that all those that return true precede all those that return false.
│ │ │ │ -Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ -    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ +    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    source§
    impl FusedIterator for SplitAsciiWhitespace<'_>
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    source§
    impl FusedIterator for SplitAsciiWhitespace<'_>
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitInclusive.html
│ │ │ │ @@ -1,233 +1,233 @@
│ │ │ │  SplitInclusive in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::SplitInclusive
    1.51.0 · source · 
    pub struct SplitInclusive<'a, P>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::SplitInclusive
    1.51.0 · source · 
    pub struct SplitInclusive<'a, P>(/* private fields */)
│ │ │ │  where
│ │ │ │      P: Pattern<'a>;
    Expand description
    An iterator over the substrings of a string,
│ │ │ │  terminated by a substring matching to a predicate function
│ │ │ │  Unlike Split, it contains the matched part as a terminator
│ │ │ │  of the subslice.
    
│ │ │ │ -
    This struct is created by the split_inclusive method on str.
│ │ │ │ +
    This struct is created by the split_inclusive method on str.
│ │ │ │  See its documentation for more.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, P> SplitInclusive<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_inclusive_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, P> SplitInclusive<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_inclusive_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │  
    If the iterator is empty, returns None.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(str_split_inclusive_remainder)]
│ │ │ │  let mut split = "Mary had a little lamb".split_inclusive(' ');
│ │ │ │  assert_eq!(split.remainder(), Some("Mary had a little lamb"));
│ │ │ │  split.next();
│ │ │ │  assert_eq!(split.remainder(), Some("had a little lamb"));
│ │ │ │  split.by_ref().for_each(drop);
│ │ │ │  assert_eq!(split.remainder(), None);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, P> Clone for SplitInclusive<'a, P>
    where
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, P> Clone for SplitInclusive<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> SplitInclusive<'a, P> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for SplitInclusive<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> SplitInclusive<'a, P> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for SplitInclusive<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for SplitInclusive<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for SplitInclusive<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for SplitInclusive<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for SplitInclusive<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    source§
    impl<'a, P> FusedIterator for SplitInclusive<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for SplitInclusive<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for SplitInclusive<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for SplitInclusive<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for SplitInclusive<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for SplitInclusive<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for SplitInclusive<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    source§
    impl<'a, P> FusedIterator for SplitInclusive<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for SplitInclusive<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for SplitInclusive<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for SplitInclusive<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for SplitInclusive<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for SplitInclusive<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for SplitInclusive<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitN.html
│ │ │ │ @@ -1,217 +1,217 @@
│ │ │ │  SplitN in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::SplitN
    1.0.0 · source · 
    pub struct SplitN<'a, P>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::SplitN
    1.0.0 · source · 
    pub struct SplitN<'a, P>(/* private fields */)
│ │ │ │  where
│ │ │ │ -    P: Pattern<'a>;
    Expand description
    Created with the method splitn.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, P> SplitN<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │ +    P: Pattern<'a>;
    Expand description
    Created with the method splitn.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, P> SplitN<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │  
    If the iterator is empty, returns None.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(str_split_remainder)]
│ │ │ │  let mut split = "Mary had a little lamb".splitn(3, ' ');
│ │ │ │  assert_eq!(split.remainder(), Some("Mary had a little lamb"));
│ │ │ │  split.next();
│ │ │ │  assert_eq!(split.remainder(), Some("had a little lamb"));
│ │ │ │  split.by_ref().for_each(drop);
│ │ │ │  assert_eq!(split.remainder(), None);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, P> Clone for SplitN<'a, P>
    where
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, P> Clone for SplitN<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> SplitN<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for SplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> SplitN<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for SplitN<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> Iterator for SplitN<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> Iterator for SplitN<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for SplitN<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for SplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for SplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for SplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for SplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for SplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for SplitN<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for SplitN<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for SplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for SplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for SplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for SplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for SplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for SplitN<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitTerminator.html
│ │ │ │ @@ -1,228 +1,228 @@
│ │ │ │  SplitTerminator in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::SplitTerminator
    1.0.0 · source · 
    pub struct SplitTerminator<'a, P>(/* private fields */)
│ │ │ │ +    
    Struct alloc::str::SplitTerminator
    1.0.0 · source · 
    pub struct SplitTerminator<'a, P>(/* private fields */)
│ │ │ │  where
│ │ │ │ -    P: Pattern<'a>;
    Expand description
    Created with the method split_terminator.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, P> SplitTerminator<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │ +    P: Pattern<'a>;
    Expand description
    Created with the method split_terminator.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, P> SplitTerminator<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_remainder #77998)
    Returns remainder of the split string.
    
│ │ │ │  
    If the iterator is empty, returns None.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(str_split_remainder)]
│ │ │ │  let mut split = "A..B..".split_terminator('.');
│ │ │ │  assert_eq!(split.remainder(), Some("A..B.."));
│ │ │ │  split.next();
│ │ │ │  assert_eq!(split.remainder(), Some(".B.."));
│ │ │ │  split.by_ref().for_each(drop);
│ │ │ │  assert_eq!(split.remainder(), None);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, P> Clone for SplitTerminator<'a, P>
    where
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, P> Clone for SplitTerminator<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> SplitTerminator<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for SplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Clone,
    source§
    fn clone(&self) -> SplitTerminator<'a, P> ⓘ
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a, P> Debug for SplitTerminator<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for SplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a, P> DoubleEndedIterator for SplitTerminator<'a, P>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │ -    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for SplitTerminator<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a, P> Iterator for SplitTerminator<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for SplitTerminator<'a, P>
    where
│ │ │ │ -    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for SplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for SplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for SplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for SplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for SplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for SplitTerminator<'a, P>
    where
│ │ │ │ -    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<'a, P> FusedIterator for SplitTerminator<'a, P>
    where
│ │ │ │ +    P: Pattern<'a>,
    Auto Trait Implementations§
    §
    impl<'a, P> Freeze for SplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Freeze,
    §
    impl<'a, P> RefUnwindSafe for SplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: RefUnwindSafe,
    §
    impl<'a, P> Send for SplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Send,
    §
    impl<'a, P> Sync for SplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Sync,
    §
    impl<'a, P> Unpin for SplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: Unpin,
    §
    impl<'a, P> UnwindSafe for SplitTerminator<'a, P>
    where
│ │ │ │ +    <P as Pattern<'a>>::Searcher: UnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.SplitWhitespace.html
│ │ │ │ @@ -1,222 +1,222 @@
│ │ │ │  SplitWhitespace in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::SplitWhitespace
    1.1.0 · source · 
    pub struct SplitWhitespace<'a> { /* private fields */ }
    Expand description
    An iterator over the non-whitespace substrings of a string,
│ │ │ │ +    
    Struct alloc::str::SplitWhitespace
    1.1.0 · source · 
    pub struct SplitWhitespace<'a> { /* private fields */ }
    Expand description
    An iterator over the non-whitespace substrings of a string,
│ │ │ │  separated by any amount of whitespace.
    
│ │ │ │ -
    This struct is created by the split_whitespace method on str.
│ │ │ │ +
    This struct is created by the split_whitespace method on str.
│ │ │ │  See its documentation for more.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a> SplitWhitespace<'a>
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_whitespace_remainder #77998)
    Returns remainder of the split string
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a> SplitWhitespace<'a>
    source
    pub fn remainder(&self) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (str_split_whitespace_remainder #77998)
    Returns remainder of the split string
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(str_split_whitespace_remainder)]
│ │ │ │  
│ │ │ │  let mut split = "Mary had a little lamb".split_whitespace();
│ │ │ │  assert_eq!(split.remainder(), Some("Mary had a little lamb"));
│ │ │ │  
│ │ │ │  split.next();
│ │ │ │  assert_eq!(split.remainder(), Some("had a little lamb"));
│ │ │ │  
│ │ │ │  split.by_ref().for_each(drop);
│ │ │ │  assert_eq!(split.remainder(), None);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for SplitWhitespace<'a>
    source§
    fn clone(&self) -> SplitWhitespace<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for SplitWhitespace<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for SplitWhitespace<'a>
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for SplitWhitespace<'a>
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<&'a str>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for SplitWhitespace<'a>
    source§
    fn clone(&self) -> SplitWhitespace<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for SplitWhitespace<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> DoubleEndedIterator for SplitWhitespace<'a>
    source§
    fn next_back(&mut self) -> Option<&'a str>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<'a> Iterator for SplitWhitespace<'a>
    §
    type Item = &'a str
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<&'a str>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<&'a str>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │  such that all those that return true precede all those that return false.
│ │ │ │ -Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ -    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ +    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl FusedIterator for SplitWhitespace<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for SplitWhitespace<'a>
    §
    impl<'a> RefUnwindSafe for SplitWhitespace<'a>
    §
    impl<'a> Send for SplitWhitespace<'a>
    §
    impl<'a> Sync for SplitWhitespace<'a>
    §
    impl<'a> Unpin for SplitWhitespace<'a>
    §
    impl<'a> UnwindSafe for SplitWhitespace<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl FusedIterator for SplitWhitespace<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for SplitWhitespace<'a>
    §
    impl<'a> RefUnwindSafe for SplitWhitespace<'a>
    §
    impl<'a> Send for SplitWhitespace<'a>
    §
    impl<'a> Sync for SplitWhitespace<'a>
    §
    impl<'a> Unpin for SplitWhitespace<'a>
    §
    impl<'a> UnwindSafe for SplitWhitespace<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Utf8Chunk.html
│ │ │ │ @@ -1,10 +1,10 @@
│ │ │ │  Utf8Chunk in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::Utf8Chunk
    source · 
    pub struct Utf8Chunk<'a> { /* private fields */ }
    🔬This is a nightly-only experimental API. (utf8_chunks #99543)
    Expand description
    An item returned by the Utf8Chunks iterator.
    
│ │ │ │ -
    A Utf8Chunk stores a sequence of u8 up to the first broken character
│ │ │ │ +    
    Struct alloc::str::Utf8Chunk
    source · 
    pub struct Utf8Chunk<'a> { /* private fields */ }
    🔬This is a nightly-only experimental API. (utf8_chunks #99543)
    Expand description
    An item returned by the Utf8Chunks iterator.
    
│ │ │ │ +
    A Utf8Chunk stores a sequence of u8 up to the first broken character
│ │ │ │  when decoding a UTF-8 string.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(utf8_chunks)]
│ │ │ │  
│ │ │ │  use std::str::Utf8Chunks;
│ │ │ │  
│ │ │ │  // An invalid UTF-8 string
│ │ │ │ @@ -14,31 +14,31 @@
│ │ │ │  let chunk = Utf8Chunks::new(bytes).next().unwrap();
│ │ │ │  
│ │ │ │  // The first three characters are valid UTF-8
│ │ │ │  assert_eq!("foo", chunk.valid());
│ │ │ │  
│ │ │ │  // The fourth character is broken
│ │ │ │  assert_eq!(b"\xF1\x80", chunk.invalid());
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a> Utf8Chunk<'a>
    source
    pub fn valid(&self) -> &'a str
    🔬This is a nightly-only experimental API. (utf8_chunks #99543)
    Returns the next validated UTF-8 substring.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a> Utf8Chunk<'a>
    source
    pub fn valid(&self) -> &'a str
    🔬This is a nightly-only experimental API. (utf8_chunks #99543)
    Returns the next validated UTF-8 substring.
    
│ │ │ │  
    This substring can be empty at the start of the string or between
│ │ │ │  broken UTF-8 characters.
    
│ │ │ │ -
    source
    pub fn invalid(&self) -> &'a [u8]
    🔬This is a nightly-only experimental API. (utf8_chunks #99543)
    Returns the invalid sequence that caused a failure.
    
│ │ │ │ +
    source
    pub fn invalid(&self) -> &'a [u8]
    🔬This is a nightly-only experimental API. (utf8_chunks #99543)
    Returns the invalid sequence that caused a failure.
    
│ │ │ │  
    The returned slice will have a maximum length of 3 and starts after the
│ │ │ │  substring given by valid. Decoding will resume after this sequence.
    
│ │ │ │  
    If empty, this is the last chunk in the string. If non-empty, an
│ │ │ │  unexpected byte was encountered or the end of the input was reached
│ │ │ │  unexpectedly.
    
│ │ │ │ -
    Lossy decoding would replace this sequence with U+FFFD REPLACEMENT CHARACTER.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for Utf8Chunk<'a>
    source§
    fn clone(&self) -> Utf8Chunk<'a>
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for Utf8Chunk<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> PartialEq for Utf8Chunk<'a>
    source§
    fn eq(&self, other: &Utf8Chunk<'a>) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    1.0.0 · source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl<'a> Eq for Utf8Chunk<'a>
    source§
    impl<'a> StructuralPartialEq for Utf8Chunk<'a>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Utf8Chunk<'a>
    §
    impl<'a> RefUnwindSafe for Utf8Chunk<'a>
    §
    impl<'a> Send for Utf8Chunk<'a>
    §
    impl<'a> Sync for Utf8Chunk<'a>
    §
    impl<'a> Unpin for Utf8Chunk<'a>
    §
    impl<'a> UnwindSafe for Utf8Chunk<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    Lossy decoding would replace this sequence with U+FFFD REPLACEMENT CHARACTER.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for Utf8Chunk<'a>
    source§
    fn clone(&self) -> Utf8Chunk<'a>
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<'a> Debug for Utf8Chunk<'a>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> PartialEq for Utf8Chunk<'a>
    source§
    fn eq(&self, other: &Utf8Chunk<'a>) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    1.0.0 · source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl<'a> Eq for Utf8Chunk<'a>
    source§
    impl<'a> StructuralPartialEq for Utf8Chunk<'a>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Utf8Chunk<'a>
    §
    impl<'a> RefUnwindSafe for Utf8Chunk<'a>
    §
    impl<'a> Send for Utf8Chunk<'a>
    §
    impl<'a> Sync for Utf8Chunk<'a>
    §
    impl<'a> Unpin for Utf8Chunk<'a>
    §
    impl<'a> UnwindSafe for Utf8Chunk<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │  
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Utf8Chunks.html
│ │ │ │ @@ -1,10 +1,10 @@
│ │ │ │  Utf8Chunks in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::Utf8Chunks
    source · 
    pub struct Utf8Chunks<'a> { /* private fields */ }
    🔬This is a nightly-only experimental API. (utf8_chunks #99543)
    Expand description
    An iterator used to decode a slice of mostly UTF-8 bytes to string slices
│ │ │ │ -(&str) and byte slices (&[u8]).
    
│ │ │ │ +    
    Struct alloc::str::Utf8Chunks
    source · 
    pub struct Utf8Chunks<'a> { /* private fields */ }
    🔬This is a nightly-only experimental API. (utf8_chunks #99543)
    Expand description
    An iterator used to decode a slice of mostly UTF-8 bytes to string slices
│ │ │ │ +(&str) and byte slices (&[u8]).
    
│ │ │ │  
    If you want a simple conversion from UTF-8 byte slices to string slices,
│ │ │ │  from_utf8 is easier to use.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    This can be used to create functionality similar to
│ │ │ │  String::from_utf8_lossy without allocating heap memory:
    
│ │ │ │  
│ │ │ │  
    #![feature(utf8_chunks)]
│ │ │ │ @@ -16,199 +16,199 @@
│ │ │ │          push(chunk.valid());
│ │ │ │  
│ │ │ │          if !chunk.invalid().is_empty() {
│ │ │ │              push("\u{FFFD}");
│ │ │ │          }
│ │ │ │      }
│ │ │ │  }
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a> Utf8Chunks<'a>
    source
    pub fn new(bytes: &'a [u8]) -> Utf8Chunks<'a> ⓘ
    🔬This is a nightly-only experimental API. (utf8_chunks #99543)
    Creates a new iterator to decode the bytes.
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a> Clone for Utf8Chunks<'a>
    source§
    fn clone(&self) -> Utf8Chunks<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for Utf8Chunks<'_>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Iterator for Utf8Chunks<'a>
    §
    type Item = Utf8Chunk<'a>
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<Utf8Chunk<'a>>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Implementations§
    source§
    impl<'a> Utf8Chunks<'a>
    source
    pub fn new(bytes: &'a [u8]) -> Utf8Chunks<'a> ⓘ
    🔬This is a nightly-only experimental API. (utf8_chunks #99543)
    Creates a new iterator to decode the bytes.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a> Clone for Utf8Chunks<'a>
    source§
    fn clone(&self) -> Utf8Chunks<'a> ⓘ
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for Utf8Chunks<'_>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl<'a> Iterator for Utf8Chunks<'a>
    §
    type Item = Utf8Chunk<'a>
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<Utf8Chunk<'a>>
    Advances the iterator and returns the next value. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ -    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    1.0.0 · source§
    fn cycle(self) -> Cycle<Self>
    where
│ │ │ │ +    Self: Sized + Clone,
    Repeats an iterator endlessly. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    source§
    impl FusedIterator for Utf8Chunks<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Utf8Chunks<'a>
    §
    impl<'a> RefUnwindSafe for Utf8Chunks<'a>
    §
    impl<'a> Send for Utf8Chunks<'a>
    §
    impl<'a> Sync for Utf8Chunks<'a>
    §
    impl<'a> Unpin for Utf8Chunks<'a>
    §
    impl<'a> UnwindSafe for Utf8Chunks<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    source§
    impl FusedIterator for Utf8Chunks<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Utf8Chunks<'a>
    §
    impl<'a> RefUnwindSafe for Utf8Chunks<'a>
    §
    impl<'a> Send for Utf8Chunks<'a>
    §
    impl<'a> Sync for Utf8Chunks<'a>
    §
    impl<'a> Unpin for Utf8Chunks<'a>
    §
    impl<'a> UnwindSafe for Utf8Chunks<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/struct.Utf8Error.html
│ │ │ │ @@ -1,9 +1,9 @@
│ │ │ │  Utf8Error in alloc::str - Rust
    
│ │ │ │ -    
    Struct alloc::str::Utf8Error
    1.0.0 · source · 
    pub struct Utf8Error { /* private fields */ }
    Expand description
    Errors which can occur when attempting to interpret a sequence of u8
│ │ │ │ +    
    Struct alloc::str::Utf8Error
    1.0.0 · source · 
    pub struct Utf8Error { /* private fields */ }
    Expand description
    Errors which can occur when attempting to interpret a sequence of u8
│ │ │ │  as a string.
    
│ │ │ │  
    As such, the from_utf8 family of functions and methods for both Strings
│ │ │ │  and &strs make use of this error, for example.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    This error type’s methods can be used to create functionality
│ │ │ │  similar to String::from_utf8_lossy without allocating heap memory:
    
│ │ │ │  
│ │ │ │ @@ -26,15 +26,15 @@
│ │ │ │                  } else {
│ │ │ │                      break
│ │ │ │                  }
│ │ │ │              }
│ │ │ │          }
│ │ │ │      }
│ │ │ │  }Run
    
│ │ │ │ -
    Implementations§
    source§
    impl Utf8Error
    1.5.0 (const: 1.63.0) · source
    pub const fn valid_up_to(&self) -> usize
    Returns the index in the given string up to which valid UTF-8 was
│ │ │ │ +
    Implementations§
    source§
    impl Utf8Error
    1.5.0 (const: 1.63.0) · source
    pub const fn valid_up_to(&self) -> usize
    Returns the index in the given string up to which valid UTF-8 was
│ │ │ │  verified.
    
│ │ │ │  
    It is the maximum index such that from_utf8(&input[..index])
│ │ │ │  would return Ok(_).
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    use std::str;
│ │ │ │ @@ -43,15 +43,15 @@
│ │ │ │  let sparkle_heart = vec![0, 159, 146, 150];
│ │ │ │  
│ │ │ │  // std::str::from_utf8 returns a Utf8Error
│ │ │ │  let error = str::from_utf8(&sparkle_heart).unwrap_err();
│ │ │ │  
│ │ │ │  // the second byte is invalid here
│ │ │ │  assert_eq!(1, error.valid_up_to());
    Run
    
│ │ │ │ -
    1.20.0 (const: 1.63.0) · source
    pub const fn error_len(&self) -> Option<usize>
    Provides more information about the failure:
    
│ │ │ │ +
    1.20.0 (const: 1.63.0) · source
    pub const fn error_len(&self) -> Option<usize>
    Provides more information about the failure:
    
│ │ │ │  
      
│ │ │ │  
    • 
│ │ │ │  
      None: the end of the input was reached unexpectedly.
│ │ │ │  self.valid_up_to() is 1 to 3 bytes from the end of the input.
│ │ │ │  If a byte stream (such as a file or a network socket) is being decoded incrementally,
│ │ │ │  this could be a valid char whose UTF-8 byte sequence is spanning multiple chunks.
      
│ │ │ │  
      • 
│ │ │ │ @@ -60,22 +60,22 @@
│ │ │ │  The length provided is that of the invalid byte sequence
│ │ │ │  that starts at the index given by valid_up_to().
│ │ │ │  Decoding should resume after that sequence
│ │ │ │  (after inserting a U+FFFD REPLACEMENT CHARACTER) in case of
│ │ │ │  lossy decoding.
      
│ │ │ │  
│ │ │ │  
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl Clone for Utf8Error
    source§
    fn clone(&self) -> Utf8Error
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for Utf8Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl Display for Utf8Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl Error for Utf8Error
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    1.30.0 · source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn provide<'a>(&'a self, request: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§
    impl PartialEq for Utf8Error
    source§
    fn eq(&self, other: &Utf8Error) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl Copy for Utf8Error
    source§
    impl Eq for Utf8Error
    source§
    impl StructuralPartialEq for Utf8Error
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl Clone for Utf8Error
    source§
    fn clone(&self) -> Utf8Error
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for Utf8Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl Display for Utf8Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
    Formats the value using the given formatter. Read more
    source§
    impl Error for Utf8Error
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    1.30.0 · source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn provide<'a>(&'a self, request: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§
    impl PartialEq for Utf8Error
    source§
    fn eq(&self, other: &Utf8Error) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl Copy for Utf8Error
    source§
    impl Eq for Utf8Error
    source§
    impl StructuralPartialEq for Utf8Error
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │  
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ -    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ +    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/str/trait.FromStr.html
│ │ │ │ @@ -1,16 +1,16 @@
│ │ │ │  FromStr in alloc::str - Rust
    
│ │ │ │ -    
    Trait alloc::str::FromStr
    1.0.0 · source · 
    pub trait FromStr: Sized {
│ │ │ │ +    
    Trait alloc::str::FromStr
    1.0.0 · source · 
    pub trait FromStr: Sized {
│ │ │ │      type Err;
│ │ │ │  
│ │ │ │      // Required method
│ │ │ │ -    fn from_str(s: &str) -> Result<Self, Self::Err>;
│ │ │ │ +    fn from_str(s: &str) -> Result<Self, Self::Err>;
│ │ │ │  }
    Expand description
    Parse a value from a string
    
│ │ │ │  
    FromStr’s from_str method is often used implicitly, through
│ │ │ │ -str’s parse method. See parse’s documentation for examples.
    
│ │ │ │ +str’s parse method. See parse’s documentation for examples.
    
│ │ │ │  
    FromStr does not have a lifetime parameter, and so you can only parse types
│ │ │ │  that do not contain a lifetime parameter themselves. In other words, you can
│ │ │ │  parse an i32 with FromStr, but not a &i32. You can parse a struct that
│ │ │ │  contains an i32, but not one that contains an &i32.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic implementation of FromStr on an example Point type:
    
│ │ │ │  
│ │ │ │ @@ -46,22 +46,22 @@
│ │ │ │  // Explicit call
│ │ │ │  assert_eq!(Point::from_str("(1,2)"), expected);
│ │ │ │  // Implicit calls, through parse
│ │ │ │  assert_eq!("(1,2)".parse(), expected);
│ │ │ │  assert_eq!("(1,2)".parse::<Point>(), expected);
│ │ │ │  // Invalid input string
│ │ │ │  assert!(Point::from_str("(1 2)").is_err());
    Run
    
│ │ │ │ -
    Required Associated Types§
    source
    type Err
    The associated error which can be returned from parsing.
    
│ │ │ │ -
    Required Methods§
    source
    fn from_str(s: &str) -> Result<Self, Self::Err>
    Parses a string s to return a value of this type.
    
│ │ │ │ -
    If parsing succeeds, return the value inside Ok, otherwise
│ │ │ │ +
    Required Associated Types§
    source
    type Err
    The associated error which can be returned from parsing.
    
│ │ │ │ +
    Required Methods§
    source
    fn from_str(s: &str) -> Result<Self, Self::Err>
    Parses a string s to return a value of this type.
    
│ │ │ │ +
    If parsing succeeds, return the value inside Ok, otherwise
│ │ │ │  when the string is ill-formatted return an error specific to the
│ │ │ │ -inside Err. The error type is specific to the implementation of the trait.
    
│ │ │ │ +inside Err. The error type is specific to the implementation of the trait.
    
│ │ │ │  
    §Examples
    
│ │ │ │ -
    Basic usage with i32, a type that implements FromStr:
    
│ │ │ │ +
    Basic usage with i32, a type that implements FromStr:
    
│ │ │ │  
│ │ │ │  
    use std::str::FromStr;
│ │ │ │  
│ │ │ │  let s = "5";
│ │ │ │  let x = i32::from_str(s).unwrap();
│ │ │ │  
│ │ │ │  assert_eq!(5, x);
    Run
    
│ │ │ │ -
    Object Safety§
    This trait is not object safe.
    Implementors§
    1.7.0 · source§
    impl FromStr for IpAddr
    §
    type Err = AddrParseError
    source§
    impl FromStr for SocketAddr
    §
    type Err = AddrParseError
    source§
    impl FromStr for bool
    §
    type Err = ParseBoolError
    1.20.0 · source§
    impl FromStr for char
    §
    type Err = ParseCharError
    source§
    impl FromStr for f32
    §
    type Err = ParseFloatError
    source§
    impl FromStr for f64
    §
    type Err = ParseFloatError
    source§
    impl FromStr for i8
    §
    type Err = ParseIntError
    source§
    impl FromStr for i16
    §
    type Err = ParseIntError
    source§
    impl FromStr for i32
    §
    type Err = ParseIntError
    source§
    impl FromStr for i64
    §
    type Err = ParseIntError
    source§
    impl FromStr for i128
    §
    type Err = ParseIntError
    source§
    impl FromStr for isize
    §
    type Err = ParseIntError
    source§
    impl FromStr for u8
    §
    type Err = ParseIntError
    source§
    impl FromStr for u16
    §
    type Err = ParseIntError
    source§
    impl FromStr for u32
    §
    type Err = ParseIntError
    source§
    impl FromStr for u64
    §
    type Err = ParseIntError
    source§
    impl FromStr for u128
    §
    type Err = ParseIntError
    source§
    impl FromStr for usize
    §
    type Err = ParseIntError
    source§
    impl FromStr for Ipv4Addr
    §
    type Err = AddrParseError
    source§
    impl FromStr for Ipv6Addr
    §
    type Err = AddrParseError
    1.5.0 · source§
    impl FromStr for SocketAddrV4
    §
    type Err = AddrParseError
    1.5.0 · source§
    impl FromStr for SocketAddrV6
    §
    type Err = AddrParseError
    1.35.0 · source§
    impl FromStr for NonZero<i8>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<i16>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<i32>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<i64>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<i128>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<isize>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<u8>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<u16>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<u32>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<u64>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<u128>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<usize>
    §
    type Err = ParseIntError
    source§
    impl FromStr for String
    §
    type Err = Infallible
    
│ │ │ │ +
    Object Safety§
    This trait is not object safe.
    Implementors§
    1.7.0 · source§
    impl FromStr for IpAddr
    §
    type Err = AddrParseError
    source§
    impl FromStr for SocketAddr
    §
    type Err = AddrParseError
    source§
    impl FromStr for bool
    §
    type Err = ParseBoolError
    1.20.0 · source§
    impl FromStr for char
    §
    type Err = ParseCharError
    source§
    impl FromStr for f32
    §
    type Err = ParseFloatError
    source§
    impl FromStr for f64
    §
    type Err = ParseFloatError
    source§
    impl FromStr for i8
    §
    type Err = ParseIntError
    source§
    impl FromStr for i16
    §
    type Err = ParseIntError
    source§
    impl FromStr for i32
    §
    type Err = ParseIntError
    source§
    impl FromStr for i64
    §
    type Err = ParseIntError
    source§
    impl FromStr for i128
    §
    type Err = ParseIntError
    source§
    impl FromStr for isize
    §
    type Err = ParseIntError
    source§
    impl FromStr for u8
    §
    type Err = ParseIntError
    source§
    impl FromStr for u16
    §
    type Err = ParseIntError
    source§
    impl FromStr for u32
    §
    type Err = ParseIntError
    source§
    impl FromStr for u64
    §
    type Err = ParseIntError
    source§
    impl FromStr for u128
    §
    type Err = ParseIntError
    source§
    impl FromStr for usize
    §
    type Err = ParseIntError
    source§
    impl FromStr for String
    §
    type Err = Infallible
    source§
    impl FromStr for Ipv4Addr
    §
    type Err = AddrParseError
    source§
    impl FromStr for Ipv6Addr
    §
    type Err = AddrParseError
    1.5.0 · source§
    impl FromStr for SocketAddrV4
    §
    type Err = AddrParseError
    1.5.0 · source§
    impl FromStr for SocketAddrV6
    §
    type Err = AddrParseError
    1.35.0 · source§
    impl FromStr for NonZero<i8>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<i16>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<i32>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<i64>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<i128>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<isize>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<u8>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<u16>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<u32>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<u64>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<u128>
    §
    type Err = ParseIntError
    1.35.0 · source§
    impl FromStr for NonZero<usize>
    §
    type Err = ParseIntError
    
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -158,14 +158,18 @@
│ │ │ │ │  §
│ │ │ │ │  *** type Err = ParseIntError ***
│ │ │ │ │  source§
│ │ │ │ │  **** impl FromStr for usize ****
│ │ │ │ │  §
│ │ │ │ │  *** type Err = ParseIntError ***
│ │ │ │ │  source§
│ │ │ │ │ +**** impl FromStr for String ****
│ │ │ │ │ +§
│ │ │ │ │ +*** type Err = Infallible ***
│ │ │ │ │ +source§
│ │ │ │ │  **** impl FromStr for Ipv4Addr ****
│ │ │ │ │  §
│ │ │ │ │  *** type Err = AddrParseError ***
│ │ │ │ │  source§
│ │ │ │ │  **** impl FromStr for Ipv6Addr ****
│ │ │ │ │  §
│ │ │ │ │  *** type Err = AddrParseError ***
│ │ │ │ │ @@ -221,11 +225,7 @@
│ │ │ │ │  **** impl FromStr for NonZero ****
│ │ │ │ │  §
│ │ │ │ │  *** type Err = ParseIntError ***
│ │ │ │ │  1.35.0 · source§
│ │ │ │ │  **** impl FromStr for NonZero ****
│ │ │ │ │  §
│ │ │ │ │  *** type Err = ParseIntError ***
│ │ │ │ │ -source§
│ │ │ │ │ -**** impl FromStr for String ****
│ │ │ │ │ -§
│ │ │ │ │ -*** type Err = Infallible ***
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/string/index.html
│ │ │ │ @@ -25,8 +25,8 @@
│ │ │ │  let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();
│ │ │ │  
│ │ │ │  assert_eq!("💖", sparkle_heart);
│ │ │ │  
│ │ │ │  let bytes = sparkle_heart.into_bytes();
│ │ │ │  
│ │ │ │  assert_eq!(bytes, [240, 159, 146, 150]);    Run
│ │ │ │ -
    Structs§
    • Drain
      A draining iterator for String.
    • FromUtf8Error
      A possible error value when converting a String from a UTF-8 byte vector.
    • FromUtf16Error
      A possible error value when converting a String from a UTF-16 byte slice.
    • String
      A UTF-8–encoded, growable string.
    Traits§
    • ToString
      A trait for converting a value to a String.
    Type Aliases§
    
│ │ │ │ +
    Structs§
    • Drain
      A draining iterator for String.
    • FromUtf8Error
      A possible error value when converting a String from a UTF-8 byte vector.
    • FromUtf16Error
      A possible error value when converting a String from a UTF-16 byte slice.
    • String
      A UTF-8–encoded, growable string.
    Traits§
    • ToString
      A trait for converting a value to a String.
    Type Aliases§
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/string/struct.Drain.html
│ │ │ │ @@ -1,214 +1,214 @@
│ │ │ │  Drain in alloc::string - Rust
    
│ │ │ │      
    Struct alloc::string::Drain
    1.6.0 · source · 
    pub struct Drain<'a> { /* private fields */ }
    Expand description
    A draining iterator for String.
    
│ │ │ │  
    This struct is created by the drain method on String. See its
│ │ │ │  documentation for more.
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a> Drain<'a>
    1.55.0 · source
    pub fn as_str(&self) -> &str
    Returns the remaining (sub)string of this iterator as a slice.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a> Drain<'a>
    1.55.0 · source
    pub fn as_str(&self) -> &str
    Returns the remaining (sub)string of this iterator as a slice.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("abc");
│ │ │ │  let mut drain = s.drain(..);
│ │ │ │  assert_eq!(drain.as_str(), "abc");
│ │ │ │  let _ = drain.next().unwrap();
│ │ │ │  assert_eq!(drain.as_str(), "bc");
    Run
    
│ │ │ │ -
    Trait Implementations§
    1.55.0 · source§
    impl<'a> AsRef<[u8]> for Drain<'a>
    source§
    fn as_ref(&self) -> &[u8]
    Converts this type into a shared reference of the (usually inferred) input type.
    1.55.0 · source§
    impl<'a> AsRef<str> for Drain<'a>
    source§
    fn as_ref(&self) -> &str
    Converts this type into a shared reference of the (usually inferred) input type.
    1.17.0 · source§
    impl Debug for Drain<'_>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl DoubleEndedIterator for Drain<'_>
    source§
    fn next_back(&mut self) -> Option<char>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl Drop for Drain<'_>
    source§
    fn drop(&mut self)
    Executes the destructor for this type. Read more
    source§
    impl Iterator for Drain<'_>
    §
    type Item = char
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<char>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<char>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    1.55.0 · source§
    impl<'a> AsRef<[u8]> for Drain<'a>
    source§
    fn as_ref(&self) -> &[u8]
    Converts this type into a shared reference of the (usually inferred) input type.
    1.55.0 · source§
    impl<'a> AsRef<str> for Drain<'a>
    source§
    fn as_ref(&self) -> &str
    Converts this type into a shared reference of the (usually inferred) input type.
    1.17.0 · source§
    impl Debug for Drain<'_>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl DoubleEndedIterator for Drain<'_>
    source§
    fn next_back(&mut self) -> Option<char>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl Drop for Drain<'_>
    source§
    fn drop(&mut self)
    Executes the destructor for this type. Read more
    source§
    impl Iterator for Drain<'_>
    §
    type Item = char
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<char>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn last(self) -> Option<char>
    Consumes the iterator, returning the last element. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │  such that all those that return true precede all those that return false.
│ │ │ │ -Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ -    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ +    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl FusedIterator for Drain<'_>
    source§
    impl Send for Drain<'_>
    source§
    impl Sync for Drain<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Drain<'a>
    §
    impl<'a> RefUnwindSafe for Drain<'a>
    §
    impl<'a> Unpin for Drain<'a>
    §
    impl<'a> UnwindSafe for Drain<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl FusedIterator for Drain<'_>
    source§
    impl Send for Drain<'_>
    source§
    impl Sync for Drain<'_>
    Auto Trait Implementations§
    §
    impl<'a> Freeze for Drain<'a>
    §
    impl<'a> RefUnwindSafe for Drain<'a>
    §
    impl<'a> Unpin for Drain<'a>
    §
    impl<'a> UnwindSafe for Drain<'a>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/string/struct.FromUtf16Error.html
│ │ │ │ @@ -3,19 +3,19 @@
│ │ │ │  
    This type is the error type for the from_utf16 method on String.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    // 𝄞mu<invalid>ic
│ │ │ │  let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
│ │ │ │            0xD800, 0x0069, 0x0063];
│ │ │ │  
│ │ │ │  assert!(String::from_utf16(v).is_err());
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl Debug for FromUtf16Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl Display for FromUtf16Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl Error for FromUtf16Error
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    1.30.0 · source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn provide<'a>(&'a self, request: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl Debug for FromUtf16Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl Display for FromUtf16Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl Error for FromUtf16Error
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    1.30.0 · source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn provide<'a>(&'a self, request: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │  
    source§
    impl<T> ToString for T
    where
│ │ │ │ -    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/string/struct.FromUtf8Error.html
│ │ │ │ @@ -1,65 +1,65 @@
│ │ │ │  FromUtf8Error in alloc::string - Rust
    
│ │ │ │      
    Struct alloc::string::FromUtf8Error
    1.0.0 · source · 
    pub struct FromUtf8Error { /* private fields */ }
    Expand description
    A possible error value when converting a String from a UTF-8 byte vector.
    
│ │ │ │  
    This type is the error type for the from_utf8 method on String. It
│ │ │ │  is designed in such a way to carefully avoid reallocations: the
│ │ │ │  into_bytes method will give back the byte vector that was used in the
│ │ │ │  conversion attempt.
    
│ │ │ │ -
    The Utf8Error type provided by std::str represents an error that may
│ │ │ │ -occur when converting a slice of u8s to a &str. In this sense, it’s
│ │ │ │ +
    The Utf8Error type provided by std::str represents an error that may
│ │ │ │ +occur when converting a slice of u8s to a &str. In this sense, it’s
│ │ │ │  an analogue to FromUtf8Error, and you can get one from a FromUtf8Error
│ │ │ │  through the utf8_error method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    // some invalid bytes, in a vector
│ │ │ │  let bytes = vec![0, 159];
│ │ │ │  
│ │ │ │  let value = String::from_utf8(bytes);
│ │ │ │  
│ │ │ │  assert!(value.is_err());
│ │ │ │  assert_eq!(vec![0, 159], value.unwrap_err().into_bytes());
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl FromUtf8Error
    1.26.0 · source
    pub fn as_bytes(&self) -> &[u8]
    Returns a slice of u8s bytes that were attempted to convert to a String.
    
│ │ │ │ +
    Implementations§
    source§
    impl FromUtf8Error
    1.26.0 · source
    pub fn as_bytes(&self) -> &[u8]
    Returns a slice of u8s bytes that were attempted to convert to a String.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    // some invalid bytes, in a vector
│ │ │ │  let bytes = vec![0, 159];
│ │ │ │  
│ │ │ │  let value = String::from_utf8(bytes);
│ │ │ │  
│ │ │ │  assert_eq!(&[0, 159], value.unwrap_err().as_bytes());
    Run
    
│ │ │ │ -
    source
    pub fn into_bytes(self) -> Vec<u8>
    Returns the bytes that were attempted to convert to a String.
    
│ │ │ │ +
    source
    pub fn into_bytes(self) -> Vec<u8>
    Returns the bytes that were attempted to convert to a String.
    
│ │ │ │  
    This method is carefully constructed to avoid allocation. It will
│ │ │ │  consume the error, moving out the bytes, so that a copy of the bytes
│ │ │ │  does not need to be made.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    // some invalid bytes, in a vector
│ │ │ │  let bytes = vec![0, 159];
│ │ │ │  
│ │ │ │  let value = String::from_utf8(bytes);
│ │ │ │  
│ │ │ │  assert_eq!(vec![0, 159], value.unwrap_err().into_bytes());
    Run
    
│ │ │ │  
    source
    pub fn utf8_error(&self) -> Utf8Error
    Fetch a Utf8Error to get more details about the conversion failure.
    
│ │ │ │ -
    The Utf8Error type provided by std::str represents an error that may
│ │ │ │ -occur when converting a slice of u8s to a &str. In this sense, it’s
│ │ │ │ +
    The Utf8Error type provided by std::str represents an error that may
│ │ │ │ +occur when converting a slice of u8s to a &str. In this sense, it’s
│ │ │ │  an analogue to FromUtf8Error. See its documentation for more details
│ │ │ │  on using it.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    // some invalid bytes, in a vector
│ │ │ │  let bytes = vec![0, 159];
│ │ │ │  
│ │ │ │  let error = String::from_utf8(bytes).unwrap_err().utf8_error();
│ │ │ │  
│ │ │ │  // the first byte is invalid here
│ │ │ │  assert_eq!(1, error.valid_up_to());
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl Clone for FromUtf8Error
    source§
    fn clone(&self) -> FromUtf8Error
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for FromUtf8Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl Display for FromUtf8Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl Error for FromUtf8Error
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    1.30.0 · source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn provide<'a>(&'a self, request: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§
    impl PartialEq for FromUtf8Error
    source§
    fn eq(&self, other: &FromUtf8Error) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl Eq for FromUtf8Error
    source§
    impl StructuralPartialEq for FromUtf8Error
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl Clone for FromUtf8Error
    source§
    fn clone(&self) -> FromUtf8Error
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for FromUtf8Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl Display for FromUtf8Error
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl Error for FromUtf8Error
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    1.30.0 · source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn provide<'a>(&'a self, request: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    source§
    impl PartialEq for FromUtf8Error
    source§
    fn eq(&self, other: &FromUtf8Error) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl Eq for FromUtf8Error
    source§
    impl StructuralPartialEq for FromUtf8Error
    Auto Trait Implementations§
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │  
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ -    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ +    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/string/struct.String.html
│ │ │ │ @@ -1,18 +1,18 @@
│ │ │ │  String in alloc::string - Rust
    
│ │ │ │      
    Struct alloc::string::String
    1.0.0 · source · 
    pub struct String { /* private fields */ }
    Expand description
    A UTF-8–encoded, growable string.
    
│ │ │ │  
    The String type is the most common string type that has ownership over the
│ │ │ │  contents of the string. It has a close relationship with its borrowed
│ │ │ │ -counterpart, the primitive str.
    
│ │ │ │ +counterpart, the primitive str.
    
│ │ │ │  
    §Examples
    
│ │ │ │ -
    You can create a String from a literal string with String::from:
    
│ │ │ │ +
    You can create a String from a literal string with String::from:
    
│ │ │ │  
│ │ │ │  
    let hello = String::from("Hello, world!");
    Run
    
│ │ │ │ -
    You can append a char to a String with the push method, and
│ │ │ │ -append a &str with the push_str method:
    
│ │ │ │ +
    You can append a char to a String with the push method, and
│ │ │ │ +append a &str with the push_str method:
    
│ │ │ │  
│ │ │ │  
    let mut hello = String::from("Hello, ");
│ │ │ │  
│ │ │ │  hello.push('w');
│ │ │ │  hello.push_str("orld!");
    Run
    
│ │ │ │  
    If you have a vector of UTF-8 bytes, you can create a String from it with
│ │ │ │  the from_utf8 method:
    
│ │ │ │ @@ -50,28 +50,28 @@
│ │ │ │  let s = ['💖', '💖', '💖', '💖', '💖'];
│ │ │ │  let size: usize = s.into_iter().map(|c| mem::size_of_val(&c)).sum();
│ │ │ │  assert_eq!(size, 20);Run
    
│ │ │ │  
    This raises interesting questions as to how s[i] should work.
│ │ │ │  What should i be here? Several options include byte indices and
│ │ │ │  char indices but, because of UTF-8 encoding, only byte indices
│ │ │ │  would provide constant time indexing. Getting the ith char, for
│ │ │ │ -example, is available using chars:
    
│ │ │ │ +example, is available using chars:
    
│ │ │ │  
│ │ │ │  
    let s = "hello";
│ │ │ │  let third_character = s.chars().nth(2);
│ │ │ │  assert_eq!(third_character, Some('l'));
│ │ │ │  
│ │ │ │  let s = "💖💖💖💖💖";
│ │ │ │  let third_character = s.chars().nth(2);
│ │ │ │  assert_eq!(third_character, Some('💖'));
    Run
    
│ │ │ │  
    Next, what should s[i] return? Because indexing returns a reference
│ │ │ │  to underlying data it could be &u8, &[u8], or something else similar.
│ │ │ │  Since we’re only providing one index, &u8 makes the most sense but that
│ │ │ │  might not be what the user expects and can be explicitly achieved with
│ │ │ │ -as_bytes():
    
│ │ │ │ +as_bytes():
    
│ │ │ │  
│ │ │ │  
    // The first byte is 104 - the byte value of `'h'`
│ │ │ │  let s = "hello";
│ │ │ │  assert_eq!(s.as_bytes()[0], 104);
│ │ │ │  // or
│ │ │ │  assert_eq!(s.as_bytes()[0], b'h');
│ │ │ │  
│ │ │ │ @@ -85,37 +85,37 @@
│ │ │ │  
│ │ │ │  // The following will not compile!
│ │ │ │  println!("The first letter of s is {}", s[0]);
    Run
    
│ │ │ │  
    It is more clear, however, how &s[i..j] should work (that is,
│ │ │ │  indexing with a range). It should accept byte indices (to be constant-time)
│ │ │ │  and return a &str which is UTF-8 encoded. This is also called “string slicing”.
│ │ │ │  Note this will panic if the byte indices provided are not character
│ │ │ │ -boundaries - see is_char_boundary for more details. See the implementations
│ │ │ │ +boundaries - see is_char_boundary for more details. See the implementations
│ │ │ │  for SliceIndex<str> for more details on string slicing. For a non-panicking
│ │ │ │ -version of string slicing, see get.
    
│ │ │ │ -
    The bytes and chars methods return iterators over the bytes and
│ │ │ │ +version of string slicing, see get.
    
│ │ │ │ +
    The bytes and chars methods return iterators over the bytes and
│ │ │ │  codepoints of the string, respectively. To iterate over codepoints along
│ │ │ │ -with byte indices, use char_indices.
    
│ │ │ │ +with byte indices, use char_indices.
    
│ │ │ │  
    §Deref
    
│ │ │ │ -
    String implements Deref<Target = str>, and so inherits all of str’s
│ │ │ │ +
    String implements Deref<Target = str>, and so inherits all of str’s
│ │ │ │  methods. In addition, this means that you can pass a String to a
│ │ │ │ -function which takes a &str by using an ampersand (&):
    
│ │ │ │ +function which takes a &str by using an ampersand (&):
    
│ │ │ │  
│ │ │ │  
    fn takes_str(s: &str) { }
│ │ │ │  
│ │ │ │  let s = String::from("Hello");
│ │ │ │  
│ │ │ │  takes_str(&s);
    Run
    
│ │ │ │ -
    This will create a &str from the String and pass it in. This
│ │ │ │ +
    This will create a &str from the String and pass it in. This
│ │ │ │  conversion is very inexpensive, and so generally, functions will accept
│ │ │ │ -&strs as arguments unless they need a String for some specific
│ │ │ │ +&strs as arguments unless they need a String for some specific
│ │ │ │  reason.
    
│ │ │ │  
    In certain cases Rust doesn’t have enough information to make this
│ │ │ │ -conversion, known as Deref coercion. In the following example a string
│ │ │ │ -slice &'a str implements the trait TraitExample, and the function
│ │ │ │ +conversion, known as Deref coercion. In the following example a string
│ │ │ │ +slice &'a str implements the trait TraitExample, and the function
│ │ │ │  example_func takes anything that implements the trait. In this case Rust
│ │ │ │  would need to make two implicit conversions, which Rust doesn’t have the
│ │ │ │  means to do. For that reason, the following example will not compile.
    
│ │ │ │  
│ │ │ │  
    ⓘ
    trait TraitExample {}
│ │ │ │  
│ │ │ │  impl<'a> TraitExample for &'a str {}
│ │ │ │ @@ -126,25 +126,25 @@
│ │ │ │  example_func(&example_string);
    Run
    
│ │ │ │  
    There are two options that would work instead. The first would be to
│ │ │ │  change the line example_func(&example_string); to
│ │ │ │  example_func(example_string.as_str());, using the method as_str()
│ │ │ │  to explicitly extract the string slice containing the string. The second
│ │ │ │  way changes example_func(&example_string); to
│ │ │ │  example_func(&*example_string);. In this case we are dereferencing a
│ │ │ │ -String to a str, then referencing the str back to
│ │ │ │ -&str. The second way is more idiomatic, however both work to do the
│ │ │ │ +String to a str, then referencing the str back to
│ │ │ │ +&str. The second way is more idiomatic, however both work to do the
│ │ │ │  conversion explicitly rather than relying on the implicit conversion.
    
│ │ │ │  
    §Representation
    
│ │ │ │  
    A String is made up of three components: a pointer to some bytes, a
│ │ │ │  length, and a capacity. The pointer points to an internal buffer String
│ │ │ │  uses to store its data. The length is the number of bytes currently stored
│ │ │ │  in the buffer, and the capacity is the size of the buffer in bytes. As such,
│ │ │ │  the length will always be less than or equal to the capacity.
    
│ │ │ │  
    This buffer is always stored on the heap.
    
│ │ │ │ -
    You can look at these with the as_ptr, len, and capacity
│ │ │ │ +
    You can look at these with the as_ptr, len, and capacity
│ │ │ │  methods:
    
│ │ │ │  
│ │ │ │  
    use std::mem;
│ │ │ │  
│ │ │ │  let story = String::from("Once upon a time...");
│ │ │ │  
│ │ │ │  // Prevent automatically dropping the String's data
│ │ │ │ @@ -208,15 +208,15 @@
│ │ │ │  buffer. While that means that this initial operation is very
│ │ │ │  inexpensive, it may cause excessive allocation later when you add
│ │ │ │  data. If you have an idea of how much data the String will hold,
│ │ │ │  consider the with_capacity method to prevent excessive
│ │ │ │  re-allocation.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = String::new();
    Run
    
│ │ │ │ -
    source
    pub fn with_capacity(capacity: usize) -> String
    Creates a new empty String with at least the specified capacity.
    
│ │ │ │ +
    source
    pub fn with_capacity(capacity: usize) -> String
    Creates a new empty String with at least the specified capacity.
    
│ │ │ │  
    Strings have an internal buffer to hold their data. The capacity is
│ │ │ │  the length of that buffer, and can be queried with the capacity
│ │ │ │  method. This method creates an empty String, but one with an initial
│ │ │ │  buffer that can hold at least capacity bytes. This is useful when you
│ │ │ │  may be appending a bunch of data to the String, reducing the number of
│ │ │ │  reallocations it needs to do.
    
│ │ │ │  
    If the given capacity is 0, no allocation will occur, and this method
│ │ │ │ @@ -233,35 +233,35 @@
│ │ │ │      s.push('a');
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(s.capacity(), cap);
│ │ │ │  
│ │ │ │  // ...but this may make the string reallocate
│ │ │ │  s.push('a');Run
    
│ │ │ │ -
    source
    pub fn try_with_capacity(capacity: usize) -> Result<String, TryReserveError>
    🔬This is a nightly-only experimental API. (try_with_capacity #91913)
    Creates a new empty String with at least the specified capacity.
    
│ │ │ │ +
    source
    pub fn try_with_capacity(capacity: usize) -> Result<String, TryReserveError>
    🔬This is a nightly-only experimental API. (try_with_capacity #91913)
    Creates a new empty String with at least the specified capacity.
    
│ │ │ │  
    §Errors
    
│ │ │ │ -
    Returns Err if the capacity exceeds isize::MAX bytes,
│ │ │ │ +
    Returns Err if the capacity exceeds isize::MAX bytes,
│ │ │ │  or if the memory allocator reports failure.
    
│ │ │ │ -
    source
    pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error>
    Converts a vector of bytes to a String.
    
│ │ │ │ -
    A string (String) is made of bytes (u8), and a vector of bytes
│ │ │ │ +
    source
    pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error>
    Converts a vector of bytes to a String.
    
│ │ │ │ +
    A string (String) is made of bytes (u8), and a vector of bytes
│ │ │ │  (Vec<u8>) is made of bytes, so this function converts between the
│ │ │ │  two. Not all byte slices are valid Strings, however: String
│ │ │ │  requires that it is valid UTF-8. from_utf8() checks to ensure that
│ │ │ │  the bytes are valid UTF-8, and then does the conversion.
    
│ │ │ │  
    If you are sure that the byte slice is valid UTF-8, and you don’t want
│ │ │ │  to incur the overhead of the validity check, there is an unsafe version
│ │ │ │  of this function, from_utf8_unchecked, which has the same behavior
│ │ │ │  but skips the check.
    
│ │ │ │  
    This method will take care to not copy the vector, for efficiency’s
│ │ │ │  sake.
    
│ │ │ │ -
    If you need a &str instead of a String, consider
│ │ │ │ +
    If you need a &str instead of a String, consider
│ │ │ │  str::from_utf8.
    
│ │ │ │  
    The inverse of this method is into_bytes.
    
│ │ │ │  
    §Errors
    
│ │ │ │ -
    Returns Err if the slice is not UTF-8 with a description as to why the
│ │ │ │ +
    Returns Err if the slice is not UTF-8 with a description as to why the
│ │ │ │  provided bytes are not UTF-8. The vector you moved in is also included.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    // some bytes, in a vector
│ │ │ │  let sparkle_heart = vec![240, 159, 146, 150];
│ │ │ │  
│ │ │ │ @@ -273,21 +273,21 @@
│ │ │ │  
│ │ │ │  
    // some invalid bytes, in a vector
│ │ │ │  let sparkle_heart = vec![0, 159, 146, 150];
│ │ │ │  
│ │ │ │  assert!(String::from_utf8(sparkle_heart).is_err());
    Run
    
│ │ │ │  
    See the docs for FromUtf8Error for more details on what you can do
│ │ │ │  with this error.
    
│ │ │ │ -
    source
    pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str>
    Converts a slice of bytes to a string, including invalid characters.
    
│ │ │ │ -
    Strings are made of bytes (u8), and a slice of bytes
│ │ │ │ -(&[u8]) is made of bytes, so this function converts
│ │ │ │ +
    source
    pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str>
    Converts a slice of bytes to a string, including invalid characters.
    
│ │ │ │ +
    Strings are made of bytes (u8), and a slice of bytes
│ │ │ │ +(&[u8]) is made of bytes, so this function converts
│ │ │ │  between the two. Not all byte slices are valid strings, however: strings
│ │ │ │  are required to be valid UTF-8. During this conversion,
│ │ │ │  from_utf8_lossy() will replace any invalid UTF-8 sequences with
│ │ │ │ -U+FFFD REPLACEMENT CHARACTER, which looks like this: �
    
│ │ │ │ +U+FFFD REPLACEMENT CHARACTER, which looks like this: �
    
│ │ │ │  
    If you are sure that the byte slice is valid UTF-8, and you don’t want
│ │ │ │  to incur the overhead of the conversion, there is an unsafe version
│ │ │ │  of this function, from_utf8_unchecked, which has the same behavior
│ │ │ │  but skips the checks.
    
│ │ │ │  
    This function returns a Cow<'a, str>. If our byte slice is invalid
│ │ │ │  UTF-8, then we need to insert the replacement characters, which will
│ │ │ │  change the size of the string, and hence, require a String. But if
│ │ │ │ @@ -305,41 +305,41 @@
│ │ │ │  
    Incorrect bytes:
    
│ │ │ │  
│ │ │ │  
    // some invalid bytes
│ │ │ │  let input = b"Hello \xF0\x90\x80World";
│ │ │ │  let output = String::from_utf8_lossy(input);
│ │ │ │  
│ │ │ │  assert_eq!("Hello �World", output);
    Run
    
│ │ │ │ -
    source
    pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error>
    Decode a UTF-16–encoded vector v into a String, returning Err
│ │ │ │ +
    source
    pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error>
    Decode a UTF-16–encoded vector v into a String, returning Err
│ │ │ │  if v contains any invalid data.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    // 𝄞music
│ │ │ │  let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
│ │ │ │            0x0073, 0x0069, 0x0063];
│ │ │ │  assert_eq!(String::from("𝄞music"),
│ │ │ │             String::from_utf16(v).unwrap());
│ │ │ │  
│ │ │ │  // 𝄞mu<invalid>ic
│ │ │ │  let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
│ │ │ │            0xD800, 0x0069, 0x0063];
│ │ │ │  assert!(String::from_utf16(v).is_err());
    Run
    
│ │ │ │ -
    source
    pub fn from_utf16_lossy(v: &[u16]) -> String
    Decode a UTF-16–encoded slice v into a String, replacing
│ │ │ │ -invalid data with the replacement character (U+FFFD).
    
│ │ │ │ +
    source
    pub fn from_utf16_lossy(v: &[u16]) -> String
    Decode a UTF-16–encoded slice v into a String, replacing
│ │ │ │ +invalid data with the replacement character (U+FFFD).
    
│ │ │ │  
    Unlike from_utf8_lossy which returns a Cow<'a, str>,
│ │ │ │  from_utf16_lossy returns a String since the UTF-16 to UTF-8
│ │ │ │  conversion requires a memory allocation.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    // 𝄞mus<invalid>ic<invalid>
│ │ │ │  let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
│ │ │ │            0x0073, 0xDD1E, 0x0069, 0x0063,
│ │ │ │            0xD834];
│ │ │ │  
│ │ │ │  assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"),
│ │ │ │             String::from_utf16_lossy(v));
    Run
    
│ │ │ │ -
    source
    pub fn from_utf16le(v: &[u8]) -> Result<String, FromUtf16Error>
    🔬This is a nightly-only experimental API. (str_from_utf16_endian #116258)
    Decode a UTF-16LE–encoded vector v into a String, returning Err
│ │ │ │ +
    source
    pub fn from_utf16le(v: &[u8]) -> Result<String, FromUtf16Error>
    🔬This is a nightly-only experimental API. (str_from_utf16_endian #116258)
    Decode a UTF-16LE–encoded vector v into a String, returning Err
│ │ │ │  if v contains any invalid data.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    #![feature(str_from_utf16_endian)]
│ │ │ │  // 𝄞music
│ │ │ │  let v = &[0x34, 0xD8, 0x1E, 0xDD, 0x6d, 0x00, 0x75, 0x00,
│ │ │ │ @@ -347,31 +347,31 @@
│ │ │ │  assert_eq!(String::from("𝄞music"),
│ │ │ │             String::from_utf16le(v).unwrap());
│ │ │ │  
│ │ │ │  // 𝄞mu<invalid>ic
│ │ │ │  let v = &[0x34, 0xD8, 0x1E, 0xDD, 0x6d, 0x00, 0x75, 0x00,
│ │ │ │            0x00, 0xD8, 0x69, 0x00, 0x63, 0x00];
│ │ │ │  assert!(String::from_utf16le(v).is_err());
    Run
    
│ │ │ │ -
    source
    pub fn from_utf16le_lossy(v: &[u8]) -> String
    🔬This is a nightly-only experimental API. (str_from_utf16_endian #116258)
    Decode a UTF-16LE–encoded slice v into a String, replacing
│ │ │ │ -invalid data with the replacement character (U+FFFD).
    
│ │ │ │ +
    source
    pub fn from_utf16le_lossy(v: &[u8]) -> String
    🔬This is a nightly-only experimental API. (str_from_utf16_endian #116258)
    Decode a UTF-16LE–encoded slice v into a String, replacing
│ │ │ │ +invalid data with the replacement character (U+FFFD).
    
│ │ │ │  
    Unlike from_utf8_lossy which returns a Cow<'a, str>,
│ │ │ │  from_utf16le_lossy returns a String since the UTF-16 to UTF-8
│ │ │ │  conversion requires a memory allocation.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    #![feature(str_from_utf16_endian)]
│ │ │ │  // 𝄞mus<invalid>ic<invalid>
│ │ │ │  let v = &[0x34, 0xD8, 0x1E, 0xDD, 0x6d, 0x00, 0x75, 0x00,
│ │ │ │            0x73, 0x00, 0x1E, 0xDD, 0x69, 0x00, 0x63, 0x00,
│ │ │ │            0x34, 0xD8];
│ │ │ │  
│ │ │ │  assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"),
│ │ │ │             String::from_utf16le_lossy(v));
    Run
    
│ │ │ │ -
    source
    pub fn from_utf16be(v: &[u8]) -> Result<String, FromUtf16Error>
    🔬This is a nightly-only experimental API. (str_from_utf16_endian #116258)
    Decode a UTF-16BE–encoded vector v into a String, returning Err
│ │ │ │ +
    source
    pub fn from_utf16be(v: &[u8]) -> Result<String, FromUtf16Error>
    🔬This is a nightly-only experimental API. (str_from_utf16_endian #116258)
    Decode a UTF-16BE–encoded vector v into a String, returning Err
│ │ │ │  if v contains any invalid data.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    #![feature(str_from_utf16_endian)]
│ │ │ │  // 𝄞music
│ │ │ │  let v = &[0xD8, 0x34, 0xDD, 0x1E, 0x00, 0x6d, 0x00, 0x75,
│ │ │ │ @@ -379,31 +379,31 @@
│ │ │ │  assert_eq!(String::from("𝄞music"),
│ │ │ │             String::from_utf16be(v).unwrap());
│ │ │ │  
│ │ │ │  // 𝄞mu<invalid>ic
│ │ │ │  let v = &[0xD8, 0x34, 0xDD, 0x1E, 0x00, 0x6d, 0x00, 0x75,
│ │ │ │            0xD8, 0x00, 0x00, 0x69, 0x00, 0x63];
│ │ │ │  assert!(String::from_utf16be(v).is_err());
    Run
    
│ │ │ │ -
    source
    pub fn from_utf16be_lossy(v: &[u8]) -> String
    🔬This is a nightly-only experimental API. (str_from_utf16_endian #116258)
    Decode a UTF-16BE–encoded slice v into a String, replacing
│ │ │ │ -invalid data with the replacement character (U+FFFD).
    
│ │ │ │ +
    source
    pub fn from_utf16be_lossy(v: &[u8]) -> String
    🔬This is a nightly-only experimental API. (str_from_utf16_endian #116258)
    Decode a UTF-16BE–encoded slice v into a String, replacing
│ │ │ │ +invalid data with the replacement character (U+FFFD).
    
│ │ │ │  
    Unlike from_utf8_lossy which returns a Cow<'a, str>,
│ │ │ │  from_utf16le_lossy returns a String since the UTF-16 to UTF-8
│ │ │ │  conversion requires a memory allocation.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    #![feature(str_from_utf16_endian)]
│ │ │ │  // 𝄞mus<invalid>ic<invalid>
│ │ │ │  let v = &[0xD8, 0x34, 0xDD, 0x1E, 0x00, 0x6d, 0x00, 0x75,
│ │ │ │            0x00, 0x73, 0xDD, 0x1E, 0x00, 0x69, 0x00, 0x63,
│ │ │ │            0xD8, 0x34];
│ │ │ │  
│ │ │ │  assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"),
│ │ │ │             String::from_utf16be_lossy(v));
    Run
    
│ │ │ │ -
    source
    pub fn into_raw_parts(self) -> (*mut u8, usize, usize)
    🔬This is a nightly-only experimental API. (vec_into_raw_parts #65816)
    Decomposes a String into its raw components: (pointer, length, capacity).
    
│ │ │ │ +
    source
    pub fn into_raw_parts(self) -> (*mut u8, usize, usize)
    🔬This is a nightly-only experimental API. (vec_into_raw_parts #65816)
    Decomposes a String into its raw components: (pointer, length, capacity).
    
│ │ │ │  
    Returns the raw pointer to the underlying data, the length of
│ │ │ │  the string (in bytes), and the allocated capacity of the data
│ │ │ │  (in bytes). These are the same arguments in the same order as
│ │ │ │  the arguments to from_raw_parts.
    
│ │ │ │  
    After calling this function, the caller is responsible for the
│ │ │ │  memory previously managed by the String. The only way to do
│ │ │ │  this is to convert the raw pointer, length, and capacity back
│ │ │ │ @@ -414,17 +414,17 @@
│ │ │ │  let s = String::from("hello");
│ │ │ │  
│ │ │ │  let (ptr, len, cap) = s.into_raw_parts();
│ │ │ │  
│ │ │ │  let rebuilt = unsafe { String::from_raw_parts(ptr, len, cap) };
│ │ │ │  assert_eq!(rebuilt, "hello");Run
    
│ │ │ │  
    source
    pub unsafe fn from_raw_parts(
│ │ │ │ -    buf: *mut u8,
│ │ │ │ -    length: usize,
│ │ │ │ -    capacity: usize
│ │ │ │ +    buf: *mut u8,
│ │ │ │ +    length: usize,
│ │ │ │ +    capacity: usize
│ │ │ │  ) -> String
    Creates a new String from a pointer, a length and a capacity.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    This is highly unsafe, due to the number of invariants that aren’t
│ │ │ │  checked:
    
│ │ │ │  
      
│ │ │ │  
    • The memory at buf needs to have been previously allocated by the
│ │ │ │  same allocator the standard library uses, with a required alignment of exactly 1.
      • 
│ │ │ │ @@ -455,15 +455,15 @@
│ │ │ │      let len = s.len();
│ │ │ │      let capacity = s.capacity();
│ │ │ │  
│ │ │ │      let s = String::from_raw_parts(ptr, len, capacity);
│ │ │ │  
│ │ │ │      assert_eq!(String::from("hello"), s);
│ │ │ │  }Run
    
│ │ │ │ -
    source
    pub unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String
    Converts a vector of bytes to a String without checking that the
│ │ │ │ +
    source
    pub unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String
    Converts a vector of bytes to a String without checking that the
│ │ │ │  string contains valid UTF-8.
    
│ │ │ │  
    See the safe version, from_utf8, for more details.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    This function is unsafe because it does not check that the bytes passed
│ │ │ │  to it are valid UTF-8. If this constraint is violated, it may cause
│ │ │ │  memory unsafety issues with future users of the String, as the rest of
│ │ │ │  the standard library assumes that Strings are valid UTF-8.
    
│ │ │ │ @@ -472,70 +472,70 @@
│ │ │ │  let sparkle_heart = vec![240, 159, 146, 150];
│ │ │ │  
│ │ │ │  let sparkle_heart = unsafe {
│ │ │ │      String::from_utf8_unchecked(sparkle_heart)
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!("💖", sparkle_heart);Run
    
│ │ │ │ -
    source
    pub fn into_bytes(self) -> Vec<u8>
    Converts a String into a byte vector.
    
│ │ │ │ +
    source
    pub fn into_bytes(self) -> Vec<u8>
    Converts a String into a byte vector.
    
│ │ │ │  
    This consumes the String, so we do not need to copy its contents.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = String::from("hello");
│ │ │ │  let bytes = s.into_bytes();
│ │ │ │  
│ │ │ │  assert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]);
    Run
    
│ │ │ │ -
    1.7.0 · source
    pub fn as_str(&self) -> &str
    Extracts a string slice containing the entire String.
    
│ │ │ │ +
    1.7.0 · source
    pub fn as_str(&self) -> &str
    Extracts a string slice containing the entire String.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = String::from("foo");
│ │ │ │  
│ │ │ │  assert_eq!("foo", s.as_str());
    Run
    
│ │ │ │ -
    1.7.0 · source
    pub fn as_mut_str(&mut self) -> &mut str
    Converts a String into a mutable string slice.
    
│ │ │ │ +
    1.7.0 · source
    pub fn as_mut_str(&mut self) -> &mut str
    Converts a String into a mutable string slice.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("foobar");
│ │ │ │  let s_mut_str = s.as_mut_str();
│ │ │ │  
│ │ │ │  s_mut_str.make_ascii_uppercase();
│ │ │ │  
│ │ │ │  assert_eq!("FOOBAR", s_mut_str);
    Run
    
│ │ │ │ -
    source
    pub fn push_str(&mut self, string: &str)
    Appends a given string slice onto the end of this String.
    
│ │ │ │ +
    source
    pub fn push_str(&mut self, string: &str)
    Appends a given string slice onto the end of this String.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("foo");
│ │ │ │  
│ │ │ │  s.push_str("bar");
│ │ │ │  
│ │ │ │  assert_eq!("foobar", s);
    Run
    
│ │ │ │  
    source
    pub fn extend_from_within<R>(&mut self, src: R)
    where
│ │ │ │ -    R: RangeBounds<usize>,
    🔬This is a nightly-only experimental API. (string_extend_from_within #103806)
    Copies elements from src range to the end of the string.
    
│ │ │ │ +    R: RangeBounds<usize>,
    🔬This is a nightly-only experimental API. (string_extend_from_within #103806)
    Copies elements from src range to the end of the string.
    
│ │ │ │  
    §Panics
    
│ │ │ │ -
    Panics if the starting point or end point do not lie on a char
│ │ │ │ +
    Panics if the starting point or end point do not lie on a char
│ │ │ │  boundary, or if they’re out of bounds.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(string_extend_from_within)]
│ │ │ │  let mut string = String::from("abcde");
│ │ │ │  
│ │ │ │  string.extend_from_within(2..);
│ │ │ │  assert_eq!(string, "abcdecde");
│ │ │ │  
│ │ │ │  string.extend_from_within(..2);
│ │ │ │  assert_eq!(string, "abcdecdeab");
│ │ │ │  
│ │ │ │  string.extend_from_within(4..8);
│ │ │ │  assert_eq!(string, "abcdecdeabecde");
    Run
    
│ │ │ │ -
    source
    pub fn capacity(&self) -> usize
    Returns this String’s capacity, in bytes.
    
│ │ │ │ +
    source
    pub fn capacity(&self) -> usize
    Returns this String’s capacity, in bytes.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = String::with_capacity(10);
│ │ │ │  
│ │ │ │  assert!(s.capacity() >= 10);
    Run
    
│ │ │ │ -
    source
    pub fn reserve(&mut self, additional: usize)
    Reserves capacity for at least additional bytes more than the
│ │ │ │ +
    source
    pub fn reserve(&mut self, additional: usize)
    Reserves capacity for at least additional bytes more than the
│ │ │ │  current length. The allocator may reserve more space to speculatively
│ │ │ │  avoid frequent allocations. After calling reserve,
│ │ │ │  capacity will be greater than or equal to self.len() + additional.
│ │ │ │  Does nothing if capacity is already sufficient.
    
│ │ │ │  
    §Panics
    
│ │ │ │ -
    Panics if the new capacity overflows usize.
    
│ │ │ │ +
    Panics if the new capacity overflows usize.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    let mut s = String::new();
│ │ │ │  
│ │ │ │  s.reserve(10);
│ │ │ │  
│ │ │ │ @@ -552,22 +552,22 @@
│ │ │ │  assert!(capacity >= 10);
│ │ │ │  
│ │ │ │  // Since we already have at least an extra 8 capacity, calling this...
│ │ │ │  s.reserve(8);
│ │ │ │  
│ │ │ │  // ... doesn't actually increase.
│ │ │ │  assert_eq!(capacity, s.capacity());
    Run
    
│ │ │ │ -
    source
    pub fn reserve_exact(&mut self, additional: usize)
    Reserves the minimum capacity for at least additional bytes more than
│ │ │ │ +
    source
    pub fn reserve_exact(&mut self, additional: usize)
    Reserves the minimum capacity for at least additional bytes more than
│ │ │ │  the current length. Unlike reserve, this will not
│ │ │ │  deliberately over-allocate to speculatively avoid frequent allocations.
│ │ │ │  After calling reserve_exact, capacity will be greater than or equal to
│ │ │ │  self.len() + additional. Does nothing if the capacity is already
│ │ │ │  sufficient.
    
│ │ │ │  
    §Panics
    
│ │ │ │ -
    Panics if the new capacity overflows usize.
    
│ │ │ │ +
    Panics if the new capacity overflows usize.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    let mut s = String::new();
│ │ │ │  
│ │ │ │  s.reserve_exact(10);
│ │ │ │  
│ │ │ │ @@ -584,15 +584,15 @@
│ │ │ │  assert!(capacity >= 10);
│ │ │ │  
│ │ │ │  // Since we already have at least an extra 8 capacity, calling this...
│ │ │ │  s.reserve_exact(8);
│ │ │ │  
│ │ │ │  // ... doesn't actually increase.
│ │ │ │  assert_eq!(capacity, s.capacity());
    Run
    
│ │ │ │ -
    1.57.0 · source
    pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
    Tries to reserve capacity for at least additional bytes more than the
│ │ │ │ +
    1.57.0 · source
    pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
    Tries to reserve capacity for at least additional bytes more than the
│ │ │ │  current length. The allocator may reserve more space to speculatively
│ │ │ │  avoid frequent allocations. After calling try_reserve, capacity will be
│ │ │ │  greater than or equal to self.len() + additional if it returns
│ │ │ │  Ok(()). Does nothing if capacity is already sufficient. This method
│ │ │ │  preserves the contents even if an error occurs.
    
│ │ │ │  
    §Errors
    
│ │ │ │  
    If the capacity overflows, or the allocator reports a failure, then an error
│ │ │ │ @@ -609,16 +609,16 @@
│ │ │ │      // Now we know this can't OOM in the middle of our complex work
│ │ │ │      output.push_str(data);
│ │ │ │  
│ │ │ │      Ok(output)
│ │ │ │  }Run
    
│ │ │ │  
    1.57.0 · source
    pub fn try_reserve_exact(
│ │ │ │      &mut self,
│ │ │ │ -    additional: usize
│ │ │ │ -) -> Result<(), TryReserveError>
    Tries to reserve the minimum capacity for at least additional bytes
│ │ │ │ +    additional: usize
│ │ │ │ +) -> Result<(), TryReserveError>
    Tries to reserve the minimum capacity for at least additional bytes
│ │ │ │  more than the current length. Unlike try_reserve, this will not
│ │ │ │  deliberately over-allocate to speculatively avoid frequent allocations.
│ │ │ │  After calling try_reserve_exact, capacity will be greater than or
│ │ │ │  equal to self.len() + additional if it returns Ok(()).
│ │ │ │  Does nothing if the capacity is already sufficient.
    
│ │ │ │  
    Note that the allocator may give the collection more space than it
│ │ │ │  requests. Therefore, capacity can not be relied upon to be precisely
│ │ │ │ @@ -645,72 +645,72 @@
│ │ │ │  
    let mut s = String::from("foo");
│ │ │ │  
│ │ │ │  s.reserve(100);
│ │ │ │  assert!(s.capacity() >= 100);
│ │ │ │  
│ │ │ │  s.shrink_to_fit();
│ │ │ │  assert_eq!(3, s.capacity());
    Run
    
│ │ │ │ -
    1.56.0 · source
    pub fn shrink_to(&mut self, min_capacity: usize)
    Shrinks the capacity of this String with a lower bound.
    
│ │ │ │ +
    1.56.0 · source
    pub fn shrink_to(&mut self, min_capacity: usize)
    Shrinks the capacity of this String with a lower bound.
    
│ │ │ │  
    The capacity will remain at least as large as both the length
│ │ │ │  and the supplied value.
    
│ │ │ │  
    If the current capacity is less than the lower limit, this is a no-op.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("foo");
│ │ │ │  
│ │ │ │  s.reserve(100);
│ │ │ │  assert!(s.capacity() >= 100);
│ │ │ │  
│ │ │ │  s.shrink_to(10);
│ │ │ │  assert!(s.capacity() >= 10);
│ │ │ │  s.shrink_to(0);
│ │ │ │  assert!(s.capacity() >= 3);
    Run
    
│ │ │ │ -
    source
    pub fn push(&mut self, ch: char)
    Appends the given char to the end of this String.
    
│ │ │ │ +
    source
    pub fn push(&mut self, ch: char)
    Appends the given char to the end of this String.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("abc");
│ │ │ │  
│ │ │ │  s.push('1');
│ │ │ │  s.push('2');
│ │ │ │  s.push('3');
│ │ │ │  
│ │ │ │  assert_eq!("abc123", s);
    Run
    
│ │ │ │ -
    source
    pub fn as_bytes(&self) -> &[u8]
    Returns a byte slice of this String’s contents.
    
│ │ │ │ +
    source
    pub fn as_bytes(&self) -> &[u8]
    Returns a byte slice of this String’s contents.
    
│ │ │ │  
    The inverse of this method is from_utf8.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = String::from("hello");
│ │ │ │  
│ │ │ │  assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
    Run
    
│ │ │ │ -
    source
    pub fn truncate(&mut self, new_len: usize)
    Shortens this String to the specified length.
    
│ │ │ │ +
    source
    pub fn truncate(&mut self, new_len: usize)
    Shortens this String to the specified length.
    
│ │ │ │  
    If new_len is greater than the string’s current length, this has no
│ │ │ │  effect.
    
│ │ │ │  
    Note that this method has no effect on the allocated capacity
│ │ │ │  of the string
    
│ │ │ │  
    §Panics
    
│ │ │ │ -
    Panics if new_len does not lie on a char boundary.
    
│ │ │ │ +
    Panics if new_len does not lie on a char boundary.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("hello");
│ │ │ │  
│ │ │ │  s.truncate(2);
│ │ │ │  
│ │ │ │  assert_eq!("he", s);
    Run
    
│ │ │ │ -
    source
    pub fn pop(&mut self) -> Option<char>
    Removes the last character from the string buffer and returns it.
    
│ │ │ │ -
    Returns None if this String is empty.
    
│ │ │ │ +
    source
    pub fn pop(&mut self) -> Option<char>
    Removes the last character from the string buffer and returns it.
    
│ │ │ │ +
    Returns None if this String is empty.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("abč");
│ │ │ │  
│ │ │ │  assert_eq!(s.pop(), Some('č'));
│ │ │ │  assert_eq!(s.pop(), Some('b'));
│ │ │ │  assert_eq!(s.pop(), Some('a'));
│ │ │ │  
│ │ │ │  assert_eq!(s.pop(), None);
    Run
    
│ │ │ │ -
    source
    pub fn remove(&mut self, idx: usize) -> char
    Removes a char from this String at a byte position and returns it.
    
│ │ │ │ +
    source
    pub fn remove(&mut self, idx: usize) -> char
    Removes a char from this String at a byte position and returns it.
    
│ │ │ │  
    This is an O(n) operation, as it requires copying every element in the
│ │ │ │  buffer.
    
│ │ │ │  
    §Panics
    
│ │ │ │  
    Panics if idx is larger than or equal to the String’s length,
│ │ │ │ -or if it does not lie on a char boundary.
    
│ │ │ │ +or if it does not lie on a char boundary.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("abç");
│ │ │ │  
│ │ │ │  assert_eq!(s.remove(0), 'a');
│ │ │ │  assert_eq!(s.remove(1), 'ç');
│ │ │ │  assert_eq!(s.remove(0), 'b');
    Run
    
│ │ │ │  
    source
    pub fn remove_matches<'a, P>(&'a mut self, pat: P)
    where
│ │ │ │ @@ -724,15 +724,15 @@
│ │ │ │  patterns overlap, only the first pattern will be removed:
    
│ │ │ │  
│ │ │ │  
    #![feature(string_remove_matches)]
│ │ │ │  let mut s = String::from("banana");
│ │ │ │  s.remove_matches("ana");
│ │ │ │  assert_eq!("bna", s);
    Run
    
│ │ │ │  
    1.26.0 · source
    pub fn retain<F>(&mut self, f: F)
    where
│ │ │ │ -    F: FnMut(char) -> bool,
    Retains only the characters specified by the predicate.
    
│ │ │ │ +    F: FnMut(char) -> bool,
    Retains only the characters specified by the predicate.
    
│ │ │ │  
    In other words, remove all characters c such that f(c) returns false.
│ │ │ │  This method operates in place, visiting each character exactly once in the
│ │ │ │  original order, and preserves the order of the retained characters.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("f_o_ob_ar");
│ │ │ │  
│ │ │ │  s.retain(|c| c != '_');
│ │ │ │ @@ -742,41 +742,41 @@
│ │ │ │  external state may be used to decide which elements to keep.
    
│ │ │ │  
│ │ │ │  
    let mut s = String::from("abcde");
│ │ │ │  let keep = [false, true, true, false, true];
│ │ │ │  let mut iter = keep.iter();
│ │ │ │  s.retain(|_| *iter.next().unwrap());
│ │ │ │  assert_eq!(s, "bce");
    Run
    
│ │ │ │ -
    source
    pub fn insert(&mut self, idx: usize, ch: char)
    Inserts a character into this String at a byte position.
    
│ │ │ │ +
    source
    pub fn insert(&mut self, idx: usize, ch: char)
    Inserts a character into this String at a byte position.
    
│ │ │ │  
    This is an O(n) operation as it requires copying every element in the
│ │ │ │  buffer.
    
│ │ │ │  
    §Panics
    
│ │ │ │  
    Panics if idx is larger than the String’s length, or if it does not
│ │ │ │ -lie on a char boundary.
    
│ │ │ │ +lie on a char boundary.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::with_capacity(3);
│ │ │ │  
│ │ │ │  s.insert(0, 'f');
│ │ │ │  s.insert(1, 'o');
│ │ │ │  s.insert(2, 'o');
│ │ │ │  
│ │ │ │  assert_eq!("foo", s);
    Run
    
│ │ │ │ -
    1.16.0 · source
    pub fn insert_str(&mut self, idx: usize, string: &str)
    Inserts a string slice into this String at a byte position.
    
│ │ │ │ +
    1.16.0 · source
    pub fn insert_str(&mut self, idx: usize, string: &str)
    Inserts a string slice into this String at a byte position.
    
│ │ │ │  
    This is an O(n) operation as it requires copying every element in the
│ │ │ │  buffer.
    
│ │ │ │  
    §Panics
    
│ │ │ │  
    Panics if idx is larger than the String’s length, or if it does not
│ │ │ │ -lie on a char boundary.
    
│ │ │ │ +lie on a char boundary.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("bar");
│ │ │ │  
│ │ │ │  s.insert_str(0, "foo");
│ │ │ │  
│ │ │ │  assert_eq!("foobar", s);
    Run
    
│ │ │ │ -
    source
    pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8>
    Returns a mutable reference to the contents of this String.
    
│ │ │ │ +
    source
    pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8>
    Returns a mutable reference to the contents of this String.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    This function is unsafe because the returned &mut Vec allows writing
│ │ │ │  bytes which are not valid UTF-8. If this constraint is violated, using
│ │ │ │  the original String after dropping the &mut Vec may violate memory
│ │ │ │  safety, as the rest of the standard library assumes that Strings are
│ │ │ │  valid UTF-8.
    
│ │ │ │  
    §Examples
    
│ │ │ │ @@ -785,32 +785,32 @@
│ │ │ │  unsafe {
│ │ │ │      let vec = s.as_mut_vec();
│ │ │ │      assert_eq!(&[104, 101, 108, 108, 111][..], &vec[..]);
│ │ │ │  
│ │ │ │      vec.reverse();
│ │ │ │  }
│ │ │ │  assert_eq!(s, "olleh");    Run
    
│ │ │ │ -
    source
    pub fn len(&self) -> usize
    Returns the length of this String, in bytes, not chars or
│ │ │ │ +
    source
    pub fn len(&self) -> usize
    Returns the length of this String, in bytes, not chars or
│ │ │ │  graphemes. In other words, it might not be what a human considers the
│ │ │ │  length of the string.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let a = String::from("foo");
│ │ │ │  assert_eq!(a.len(), 3);
│ │ │ │  
│ │ │ │  let fancy_f = String::from("ƒoo");
│ │ │ │  assert_eq!(fancy_f.len(), 4);
│ │ │ │  assert_eq!(fancy_f.chars().count(), 3);
    Run
    
│ │ │ │ -
    source
    pub fn is_empty(&self) -> bool
    Returns true if this String has a length of zero, and false otherwise.
    
│ │ │ │ +
    source
    pub fn is_empty(&self) -> bool
    Returns true if this String has a length of zero, and false otherwise.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut v = String::new();
│ │ │ │  assert!(v.is_empty());
│ │ │ │  
│ │ │ │  v.push('a');
│ │ │ │  assert!(!v.is_empty());
    Run
    
│ │ │ │ -
    1.16.0 · source
    pub fn split_off(&mut self, at: usize) -> String
    Splits the string into two at the given byte index.
    
│ │ │ │ +
    1.16.0 · source
    pub fn split_off(&mut self, at: usize) -> String
    Splits the string into two at the given byte index.
    
│ │ │ │  
    Returns a newly allocated String. self contains bytes [0, at), and
│ │ │ │  the returned String contains bytes [at, len). at must be on the
│ │ │ │  boundary of a UTF-8 code point.
    
│ │ │ │  
    Note that the capacity of self does not change.
    
│ │ │ │  
    §Panics
    
│ │ │ │  
    Panics if at is not on a UTF-8 code point boundary, or if it is beyond the last
│ │ │ │  code point of the string.
    
│ │ │ │ @@ -827,72 +827,72 @@
│ │ │ │  
│ │ │ │  s.clear();
│ │ │ │  
│ │ │ │  assert!(s.is_empty());
│ │ │ │  assert_eq!(0, s.len());
│ │ │ │  assert_eq!(3, s.capacity());Run
    
│ │ │ │  
    1.6.0 · source
    pub fn drain<R>(&mut self, range: R) -> Drain<'_> ⓘ
    where
│ │ │ │ -    R: RangeBounds<usize>,
    Removes the specified range from the string in bulk, returning all
│ │ │ │ +    R: RangeBounds<usize>,
    Removes the specified range from the string in bulk, returning all
│ │ │ │  removed characters as an iterator.
    
│ │ │ │  
    The returned iterator keeps a mutable borrow on the string to optimize
│ │ │ │  its implementation.
    
│ │ │ │  
    §Panics
    
│ │ │ │ -
    Panics if the starting point or end point do not lie on a char
│ │ │ │ +
    Panics if the starting point or end point do not lie on a char
│ │ │ │  boundary, or if they’re out of bounds.
    
│ │ │ │  
    §Leaking
    
│ │ │ │  
    If the returned iterator goes out of scope without being dropped (due to
│ │ │ │ -core::mem::forget, for example), the string may still contain a copy
│ │ │ │ +core::mem::forget, for example), the string may still contain a copy
│ │ │ │  of any drained characters, or may have lost characters arbitrarily,
│ │ │ │  including characters outside the range.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("α is alpha, β is beta");
│ │ │ │  let beta_offset = s.find('β').unwrap_or(s.len());
│ │ │ │  
│ │ │ │  // Remove the range up until the β from the string
│ │ │ │  let t: String = s.drain(..beta_offset).collect();
│ │ │ │  assert_eq!(t, "α is alpha, ");
│ │ │ │  assert_eq!(s, "β is beta");
│ │ │ │  
│ │ │ │  // A full range clears the string, like `clear()` does
│ │ │ │  s.drain(..);
│ │ │ │  assert_eq!(s, "");
    Run
    
│ │ │ │ -
    1.27.0 · source
    pub fn replace_range<R>(&mut self, range: R, replace_with: &str)
    where
│ │ │ │ -    R: RangeBounds<usize>,
    Removes the specified range in the string,
│ │ │ │ +
    1.27.0 · source
    pub fn replace_range<R>(&mut self, range: R, replace_with: &str)
    where
│ │ │ │ +    R: RangeBounds<usize>,
    Removes the specified range in the string,
│ │ │ │  and replaces it with the given string.
│ │ │ │  The given string doesn’t need to be the same length as the range.
    
│ │ │ │  
    §Panics
    
│ │ │ │ -
    Panics if the starting point or end point do not lie on a char
│ │ │ │ +
    Panics if the starting point or end point do not lie on a char
│ │ │ │  boundary, or if they’re out of bounds.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("α is alpha, β is beta");
│ │ │ │  let beta_offset = s.find('β').unwrap_or(s.len());
│ │ │ │  
│ │ │ │  // Replace the range up until the β from the string
│ │ │ │  s.replace_range(..beta_offset, "Α is capital alpha; ");
│ │ │ │  assert_eq!(s, "Α is capital alpha; β is beta");
    Run
    
│ │ │ │ -
    1.4.0 · source
    pub fn into_boxed_str(self) -> Box<str>
    Converts this String into a Box<str>.
    
│ │ │ │ +
    1.4.0 · source
    pub fn into_boxed_str(self) -> Box<str>
    Converts this String into a Box<str>.
    
│ │ │ │  
    This will drop any excess capacity.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = String::from("hello");
│ │ │ │  
│ │ │ │  let b = s.into_boxed_str();
    Run
    
│ │ │ │ -
    1.72.0 · source
    pub fn leak<'a>(self) -> &'a mut str
    Consumes and leaks the String, returning a mutable reference to the contents,
│ │ │ │ +
    1.72.0 · source
    pub fn leak<'a>(self) -> &'a mut str
    Consumes and leaks the String, returning a mutable reference to the contents,
│ │ │ │  &'a mut str.
    
│ │ │ │  
    The caller has free choice over the returned lifetime, including 'static. Indeed,
│ │ │ │  this function is ideally used for data that lives for the remainder of the program’s life,
│ │ │ │  as dropping the returned reference will cause a memory leak.
    
│ │ │ │  
    It does not reallocate or shrink the String,
│ │ │ │  so the leaked allocation may include unused capacity that is not part
│ │ │ │  of the returned slice. If you don’t want that, call into_boxed_str,
│ │ │ │  and then Box::leak.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let x = String::from("bucket");
│ │ │ │  let static_ref: &'static mut str = x.leak();
│ │ │ │  assert_eq!(static_ref, "bucket");
    Run
    
│ │ │ │ -
    Methods from Deref<Target = str>§
    source
    pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String
    Replaces all matches of a pattern with another string.
    
│ │ │ │ +
    Methods from Deref<Target = str>§
    source
    pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String
    Replaces all matches of a pattern with another string.
    
│ │ │ │  
    replace creates a new String, and copies the data from this string slice into it.
│ │ │ │  While doing so, it attempts to find matches of a pattern. If it finds any, it
│ │ │ │  replaces them with the replacement string slice.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    let s = "this is old";
│ │ │ │ @@ -902,16 +902,16 @@
│ │ │ │  
    When the pattern doesn’t match, it returns this string slice as String:
    
│ │ │ │  
│ │ │ │  
    let s = "this is old";
│ │ │ │  assert_eq!(s, s.replace("cookie monster", "little lamb"));
    Run
    
│ │ │ │  
    1.16.0 · source
    pub fn replacen<'a, P: Pattern<'a>>(
│ │ │ │      &'a self,
│ │ │ │      pat: P,
│ │ │ │ -    to: &str,
│ │ │ │ -    count: usize
│ │ │ │ +    to: &str,
│ │ │ │ +    count: usize
│ │ │ │  ) -> String
    Replaces first N matches of a pattern with another string.
    
│ │ │ │  
    replacen creates a new String, and copies the data from this string slice into it.
│ │ │ │  While doing so, it attempts to find matches of a pattern. If it finds any, it
│ │ │ │  replaces them with the replacement string slice at most count times.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │ @@ -968,64 +968,64 @@
│ │ │ │  
│ │ │ │  assert_eq!(new_year, new_year.to_uppercase());    Run
    
│ │ │ │  
    One character can become multiple:
    
│ │ │ │  
│ │ │ │  
    let s = "tschüß";
│ │ │ │  
│ │ │ │  assert_eq!("TSCHÜSS", s.to_uppercase());
    Run
    
│ │ │ │ -
    1.16.0 · source
    pub fn repeat(&self, n: usize) -> String
    Creates a new String by repeating a string n times.
    
│ │ │ │ +
    1.16.0 · source
    pub fn repeat(&self, n: usize) -> String
    Creates a new String by repeating a string n times.
    
│ │ │ │  
    §Panics
    
│ │ │ │  
    This function will panic if the capacity would overflow.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));
    Run
    
│ │ │ │  
    A panic upon overflow:
    
│ │ │ │  
│ │ │ │  
    ⓘ
    // this will panic at runtime
│ │ │ │  let huge = "0123456789abcdef".repeat(usize::MAX);
    Run
    
│ │ │ │  
    1.23.0 · source
    pub fn to_ascii_uppercase(&self) -> String
    Returns a copy of this string where each character is mapped to its
│ │ │ │  ASCII upper case equivalent.
    
│ │ │ │  
    ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’,
│ │ │ │  but non-ASCII letters are unchanged.
    
│ │ │ │ -
    To uppercase the value in-place, use make_ascii_uppercase.
    
│ │ │ │ +
    To uppercase the value in-place, use make_ascii_uppercase.
    
│ │ │ │  
    To uppercase ASCII characters in addition to non-ASCII characters, use
│ │ │ │  to_uppercase.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = "Grüße, Jürgen ❤";
│ │ │ │  
│ │ │ │  assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase());
    Run
    
│ │ │ │  
    1.23.0 · source
    pub fn to_ascii_lowercase(&self) -> String
    Returns a copy of this string where each character is mapped to its
│ │ │ │  ASCII lower case equivalent.
    
│ │ │ │  
    ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’,
│ │ │ │  but non-ASCII letters are unchanged.
    
│ │ │ │ -
    To lowercase the value in-place, use make_ascii_lowercase.
    
│ │ │ │ +
    To lowercase the value in-place, use make_ascii_lowercase.
    
│ │ │ │  
    To lowercase ASCII characters in addition to non-ASCII characters, use
│ │ │ │  to_lowercase.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = "Grüße, Jürgen ❤";
│ │ │ │  
│ │ │ │  assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase());
    Run
    
│ │ │ │ -
    source
    pub fn len(&self) -> usize
    Returns the length of self.
    
│ │ │ │ -
    This length is in bytes, not chars or graphemes. In other words,
│ │ │ │ +
    source
    pub fn len(&self) -> usize
    Returns the length of self.
    
│ │ │ │ +
    This length is in bytes, not chars or graphemes. In other words,
│ │ │ │  it might not be what a human considers the length of the string.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let len = "foo".len();
│ │ │ │  assert_eq!(3, len);
│ │ │ │  
│ │ │ │  assert_eq!("ƒoo".len(), 4); // fancy f!
│ │ │ │  assert_eq!("ƒoo".chars().count(), 3);
    Run
    
│ │ │ │ -
    source
    pub fn is_empty(&self) -> bool
    Returns true if self has a length of zero bytes.
    
│ │ │ │ +
    source
    pub fn is_empty(&self) -> bool
    Returns true if self has a length of zero bytes.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = "";
│ │ │ │  assert!(s.is_empty());
│ │ │ │  
│ │ │ │  let s = "not empty";
│ │ │ │  assert!(!s.is_empty());
    Run
    
│ │ │ │ -
    1.9.0 · source
    pub fn is_char_boundary(&self, index: usize) -> bool
    Checks that index-th byte is the first byte in a UTF-8 code point
│ │ │ │ +
    1.9.0 · source
    pub fn is_char_boundary(&self, index: usize) -> bool
    Checks that index-th byte is the first byte in a UTF-8 code point
│ │ │ │  sequence or the end of the string.
    
│ │ │ │  
    The start and end of the string (when index == self.len()) are
│ │ │ │  considered to be boundaries.
    
│ │ │ │  
    Returns false if index is greater than self.len().
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = "Löwe 老虎 Léopard";
│ │ │ │  assert!(s.is_char_boundary(0));
│ │ │ │ @@ -1034,48 +1034,48 @@
│ │ │ │  assert!(s.is_char_boundary(s.len()));
│ │ │ │  
│ │ │ │  // second byte of `ö`
│ │ │ │  assert!(!s.is_char_boundary(2));
│ │ │ │  
│ │ │ │  // third byte of `老`
│ │ │ │  assert!(!s.is_char_boundary(8));
    Run
    
│ │ │ │ -
    source
    pub fn floor_char_boundary(&self, index: usize) -> usize
    🔬This is a nightly-only experimental API. (round_char_boundary #93743)
    Finds the closest x not exceeding index where is_char_boundary(x) is true.
    
│ │ │ │ +
    source
    pub fn floor_char_boundary(&self, index: usize) -> usize
    🔬This is a nightly-only experimental API. (round_char_boundary #93743)
    Finds the closest x not exceeding index where is_char_boundary(x) is true.
    
│ │ │ │  
    This method can help you truncate a string so that it’s still valid UTF-8, but doesn’t
│ │ │ │  exceed a given number of bytes. Note that this is done purely at the character level
│ │ │ │  and can still visually split graphemes, even though the underlying characters aren’t
│ │ │ │  split. For example, the emoji 🧑‍🔬 (scientist) could be split so that the string only
│ │ │ │  includes 🧑 (person) instead.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(round_char_boundary)]
│ │ │ │  let s = "❤️🧡💛💚💙💜";
│ │ │ │  assert_eq!(s.len(), 26);
│ │ │ │  assert!(!s.is_char_boundary(13));
│ │ │ │  
│ │ │ │  let closest = s.floor_char_boundary(13);
│ │ │ │  assert_eq!(closest, 10);
│ │ │ │  assert_eq!(&s[..closest], "❤️🧡");
    Run
    
│ │ │ │ -
    source
    pub fn ceil_char_boundary(&self, index: usize) -> usize
    🔬This is a nightly-only experimental API. (round_char_boundary #93743)
    Finds the closest x not below index where is_char_boundary(x) is true.
    
│ │ │ │ +
    source
    pub fn ceil_char_boundary(&self, index: usize) -> usize
    🔬This is a nightly-only experimental API. (round_char_boundary #93743)
    Finds the closest x not below index where is_char_boundary(x) is true.
    
│ │ │ │  
    If index is greater than the length of the string, this returns the length of the string.
    
│ │ │ │ -
    This method is the natural complement to floor_char_boundary. See that method
│ │ │ │ +
    This method is the natural complement to floor_char_boundary. See that method
│ │ │ │  for more details.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(round_char_boundary)]
│ │ │ │  let s = "❤️🧡💛💚💙💜";
│ │ │ │  assert_eq!(s.len(), 26);
│ │ │ │  assert!(!s.is_char_boundary(13));
│ │ │ │  
│ │ │ │  let closest = s.ceil_char_boundary(13);
│ │ │ │  assert_eq!(closest, 14);
│ │ │ │  assert_eq!(&s[..closest], "❤️🧡💛");
    Run
    
│ │ │ │ -
    source
    pub fn as_bytes(&self) -> &[u8]
    Converts a string slice to a byte slice. To convert the byte slice back
│ │ │ │ +
    source
    pub fn as_bytes(&self) -> &[u8]
    Converts a string slice to a byte slice. To convert the byte slice back
│ │ │ │  into a string slice, use the from_utf8 function.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let bytes = "bors".as_bytes();
│ │ │ │  assert_eq!(b"bors", bytes);
    Run
    
│ │ │ │ -
    1.20.0 · source
    pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8]
    Converts a mutable string slice to a mutable byte slice.
    
│ │ │ │ +
    1.20.0 · source
    pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8]
    Converts a mutable string slice to a mutable byte slice.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    The caller must ensure that the content of the slice is valid UTF-8
│ │ │ │  before the borrow ends and the underlying str is used.
    
│ │ │ │  
    Use of a str whose contents are not valid UTF-8 is undefined behavior.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │ @@ -1093,51 +1093,51 @@
│ │ │ │      bytes[0] = 0xF0;
│ │ │ │      bytes[1] = 0x9F;
│ │ │ │      bytes[2] = 0x8D;
│ │ │ │      bytes[3] = 0x94;
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!("🍔∈🌏", s);Run
    
│ │ │ │ -
    source
    pub fn as_ptr(&self) -> *const u8
    Converts a string slice to a raw pointer.
    
│ │ │ │ +
    source
    pub fn as_ptr(&self) -> *const u8
    Converts a string slice to a raw pointer.
    
│ │ │ │  
    As string slices are a slice of bytes, the raw pointer points to a
│ │ │ │ -u8. This pointer will be pointing to the first byte of the string
│ │ │ │ +u8. This pointer will be pointing to the first byte of the string
│ │ │ │  slice.
    
│ │ │ │  
    The caller must ensure that the returned pointer is never written to.
│ │ │ │ -If you need to mutate the contents of the string slice, use as_mut_ptr.
    
│ │ │ │ +If you need to mutate the contents of the string slice, use as_mut_ptr.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = "Hello";
│ │ │ │  let ptr = s.as_ptr();
    Run
    
│ │ │ │ -
    1.36.0 · source
    pub fn as_mut_ptr(&mut self) -> *mut u8
    Converts a mutable string slice to a raw pointer.
    
│ │ │ │ +
    1.36.0 · source
    pub fn as_mut_ptr(&mut self) -> *mut u8
    Converts a mutable string slice to a raw pointer.
    
│ │ │ │  
    As string slices are a slice of bytes, the raw pointer points to a
│ │ │ │ -u8. This pointer will be pointing to the first byte of the string
│ │ │ │ +u8. This pointer will be pointing to the first byte of the string
│ │ │ │  slice.
    
│ │ │ │  
    It is your responsibility to make sure that the string slice only gets
│ │ │ │  modified in a way that it remains valid UTF-8.
    
│ │ │ │ -
    1.20.0 · source
    pub fn get<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output>
    where
│ │ │ │ -    I: SliceIndex<str>,
    Returns a subslice of str.
    
│ │ │ │ +
    1.20.0 · source
    pub fn get<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output>
    where
│ │ │ │ +    I: SliceIndex<str>,
    Returns a subslice of str.
    
│ │ │ │  
    This is the non-panicking alternative to indexing the str. Returns
│ │ │ │ -None whenever equivalent indexing operation would panic.
    
│ │ │ │ +None whenever equivalent indexing operation would panic.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let v = String::from("🗻∈🌏");
│ │ │ │  
│ │ │ │  assert_eq!(Some("🗻"), v.get(0..4));
│ │ │ │  
│ │ │ │  // indices not on UTF-8 sequence boundaries
│ │ │ │  assert!(v.get(1..).is_none());
│ │ │ │  assert!(v.get(..8).is_none());
│ │ │ │  
│ │ │ │  // out of bounds
│ │ │ │  assert!(v.get(..42).is_none());
    Run
    
│ │ │ │ -
    1.20.0 · source
    pub fn get_mut<I>(
│ │ │ │ +
    1.20.0 · source
    pub fn get_mut<I>(
│ │ │ │      &mut self,
│ │ │ │      i: I
│ │ │ │ -) -> Option<&mut <I as SliceIndex<str>>::Output>
    where
│ │ │ │ -    I: SliceIndex<str>,
    Returns a mutable subslice of str.
    
│ │ │ │ +) -> Option<&mut <I as SliceIndex<str>>::Output>
    where
│ │ │ │ +    I: SliceIndex<str>,
    Returns a mutable subslice of str.
    
│ │ │ │  
    This is the non-panicking alternative to indexing the str. Returns
│ │ │ │ -None whenever equivalent indexing operation would panic.
    
│ │ │ │ +None whenever equivalent indexing operation would panic.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut v = String::from("hello");
│ │ │ │  // correct length
│ │ │ │  assert!(v.get_mut(0..5).is_some());
│ │ │ │  // out of bounds
│ │ │ │  assert!(v.get_mut(..42).is_none());
│ │ │ │  assert_eq!(Some("he"), v.get_mut(0..2).map(|v| &*v));
│ │ │ │ @@ -1148,16 +1148,16 @@
│ │ │ │      let s = s.map(|s| {
│ │ │ │          s.make_ascii_uppercase();
│ │ │ │          &*s
│ │ │ │      });
│ │ │ │      assert_eq!(Some("HE"), s);
│ │ │ │  }
│ │ │ │  assert_eq!("HEllo", v);
    Run
    
│ │ │ │ -
    1.20.0 · source
    pub unsafe fn get_unchecked<I>(&self, i: I) -> &<I as SliceIndex<str>>::Output
    where
│ │ │ │ -    I: SliceIndex<str>,
    Returns an unchecked subslice of str.
    
│ │ │ │ +
    1.20.0 · source
    pub unsafe fn get_unchecked<I>(&self, i: I) -> &<I as SliceIndex<str>>::Output
    where
│ │ │ │ +    I: SliceIndex<str>,
    Returns an unchecked subslice of str.
    
│ │ │ │  
    This is the unchecked alternative to indexing the str.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    Callers of this function are responsible that these preconditions are
│ │ │ │  satisfied:
    
│ │ │ │  
      
│ │ │ │  
    • The starting index must not exceed the ending index;
      • 
│ │ │ │  
    • Indexes must be within bounds of the original slice;
      • 
│ │ │ │ @@ -1168,19 +1168,19 @@
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = "🗻∈🌏";
│ │ │ │  unsafe {
│ │ │ │      assert_eq!("🗻", v.get_unchecked(0..4));
│ │ │ │      assert_eq!("∈", v.get_unchecked(4..7));
│ │ │ │      assert_eq!("🌏", v.get_unchecked(7..11));
│ │ │ │  }
      Run
      
│ │ │ │ -
    1.20.0 · source
    pub unsafe fn get_unchecked_mut<I>(
│ │ │ │ +
    1.20.0 · source
    pub unsafe fn get_unchecked_mut<I>(
│ │ │ │      &mut self,
│ │ │ │      i: I
│ │ │ │ -) -> &mut <I as SliceIndex<str>>::Output
    where
│ │ │ │ -    I: SliceIndex<str>,
    Returns a mutable, unchecked subslice of str.
    
│ │ │ │ +) -> &mut <I as SliceIndex<str>>::Output
    where
│ │ │ │ +    I: SliceIndex<str>,
    Returns a mutable, unchecked subslice of str.
    
│ │ │ │  
    This is the unchecked alternative to indexing the str.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    Callers of this function are responsible that these preconditions are
│ │ │ │  satisfied:
    
│ │ │ │  
      
│ │ │ │  
    • The starting index must not exceed the ending index;
      • 
│ │ │ │  
    • Indexes must be within bounds of the original slice;
      • 
│ │ │ │ @@ -1191,22 +1191,22 @@
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = String::from("🗻∈🌏");
│ │ │ │  unsafe {
│ │ │ │      assert_eq!("🗻", v.get_unchecked_mut(0..4));
│ │ │ │      assert_eq!("∈", v.get_unchecked_mut(4..7));
│ │ │ │      assert_eq!("🌏", v.get_unchecked_mut(7..11));
│ │ │ │  }
      Run
      
│ │ │ │ -
    source
    pub unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str
    👎Deprecated since 1.29.0: use get_unchecked(begin..end) instead
    Creates a string slice from another string slice, bypassing safety
│ │ │ │ +
    source
    pub unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str
    👎Deprecated since 1.29.0: use get_unchecked(begin..end) instead
    Creates a string slice from another string slice, bypassing safety
│ │ │ │  checks.
    
│ │ │ │  
    This is generally not recommended, use with caution! For a safe
│ │ │ │ -alternative see str and Index.
    
│ │ │ │ +alternative see str and Index.
    
│ │ │ │  
    This new slice goes from begin to end, including begin but
│ │ │ │  excluding end.
    
│ │ │ │  
    To get a mutable string slice instead, see the
│ │ │ │ -slice_mut_unchecked method.
    
│ │ │ │ +slice_mut_unchecked method.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    Callers of this function are responsible that three preconditions are
│ │ │ │  satisfied:
    
│ │ │ │  
      
│ │ │ │  
    • begin must not exceed end.
      • 
│ │ │ │  
    • begin and end must be byte positions within the string slice.
      • 
│ │ │ │  
    • begin and end must lie on UTF-8 sequence boundaries.
      • 
│ │ │ │ @@ -1219,117 +1219,117 @@
│ │ │ │  }
│ │ │ │  
│ │ │ │  let s = "Hello, world!";
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      assert_eq!("world", s.slice_unchecked(7, 12));
│ │ │ │  }Run
    
│ │ │ │ -
    1.5.0 · source
    pub unsafe fn slice_mut_unchecked(
│ │ │ │ +
    1.5.0 · source
    pub unsafe fn slice_mut_unchecked(
│ │ │ │      &mut self,
│ │ │ │ -    begin: usize,
│ │ │ │ -    end: usize
│ │ │ │ -) -> &mut str
    👎Deprecated since 1.29.0: use get_unchecked_mut(begin..end) instead
    Creates a string slice from another string slice, bypassing safety
│ │ │ │ +    begin: usize,
│ │ │ │ +    end: usize
│ │ │ │ +) -> &mut str
    👎Deprecated since 1.29.0: use get_unchecked_mut(begin..end) instead
    Creates a string slice from another string slice, bypassing safety
│ │ │ │  checks.
│ │ │ │  This is generally not recommended, use with caution! For a safe
│ │ │ │ -alternative see str and IndexMut.
    
│ │ │ │ +alternative see str and IndexMut.
    
│ │ │ │  
    This new slice goes from begin to end, including begin but
│ │ │ │  excluding end.
    
│ │ │ │  
    To get an immutable string slice instead, see the
│ │ │ │ -slice_unchecked method.
    
│ │ │ │ +slice_unchecked method.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    Callers of this function are responsible that three preconditions are
│ │ │ │  satisfied:
    
│ │ │ │  
      
│ │ │ │  
    • begin must not exceed end.
      • 
│ │ │ │  
    • begin and end must be byte positions within the string slice.
      • 
│ │ │ │  
    • begin and end must lie on UTF-8 sequence boundaries.
      • 
│ │ │ │  
    
│ │ │ │ -
    1.4.0 · source
    pub fn split_at(&self, mid: usize) -> (&str, &str)
    Divide one string slice into two at an index.
    
│ │ │ │ +
    1.4.0 · source
    pub fn split_at(&self, mid: usize) -> (&str, &str)
    Divide one string slice into two at an index.
    
│ │ │ │  
    The argument, mid, should be a byte offset from the start of the
│ │ │ │  string. It must also be on the boundary of a UTF-8 code point.
    
│ │ │ │  
    The two slices returned go from the start of the string slice to mid,
│ │ │ │  and from mid to the end of the string slice.
    
│ │ │ │ -
    To get mutable string slices instead, see the split_at_mut
│ │ │ │ +
    To get mutable string slices instead, see the split_at_mut
│ │ │ │  method.
    
│ │ │ │  
    §Panics
    
│ │ │ │  
    Panics if mid is not on a UTF-8 code point boundary, or if it is past
│ │ │ │  the end of the last code point of the string slice.  For a non-panicking
│ │ │ │ -alternative see split_at_checked.
    
│ │ │ │ +alternative see split_at_checked.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = "Per Martin-Löf";
│ │ │ │  
│ │ │ │  let (first, last) = s.split_at(3);
│ │ │ │  
│ │ │ │  assert_eq!("Per", first);
│ │ │ │  assert_eq!(" Martin-Löf", last);
    Run
    
│ │ │ │ -
    1.4.0 · source
    pub fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str)
    Divide one mutable string slice into two at an index.
    
│ │ │ │ +
    1.4.0 · source
    pub fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str)
    Divide one mutable string slice into two at an index.
    
│ │ │ │  
    The argument, mid, should be a byte offset from the start of the
│ │ │ │  string. It must also be on the boundary of a UTF-8 code point.
    
│ │ │ │  
    The two slices returned go from the start of the string slice to mid,
│ │ │ │  and from mid to the end of the string slice.
    
│ │ │ │ -
    To get immutable string slices instead, see the split_at method.
    
│ │ │ │ +
    To get immutable string slices instead, see the split_at method.
    
│ │ │ │  
    §Panics
    
│ │ │ │  
    Panics if mid is not on a UTF-8 code point boundary, or if it is past
│ │ │ │  the end of the last code point of the string slice.  For a non-panicking
│ │ │ │ -alternative see split_at_mut_checked.
    
│ │ │ │ +alternative see split_at_mut_checked.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = "Per Martin-Löf".to_string();
│ │ │ │  {
│ │ │ │      let (first, last) = s.split_at_mut(3);
│ │ │ │      first.make_ascii_uppercase();
│ │ │ │      assert_eq!("PER", first);
│ │ │ │      assert_eq!(" Martin-Löf", last);
│ │ │ │  }
│ │ │ │  assert_eq!("PER Martin-Löf", s);
    Run
    
│ │ │ │ -
    source
    pub fn split_at_checked(&self, mid: usize) -> Option<(&str, &str)>
    🔬This is a nightly-only experimental API. (split_at_checked #119128)
    Divide one string slice into two at an index.
    
│ │ │ │ +
    source
    pub fn split_at_checked(&self, mid: usize) -> Option<(&str, &str)>
    🔬This is a nightly-only experimental API. (split_at_checked #119128)
    Divide one string slice into two at an index.
    
│ │ │ │  
    The argument, mid, should be a valid byte offset from the start of the
│ │ │ │  string. It must also be on the boundary of a UTF-8 code point. The
│ │ │ │  method returns None if that’s not the case.
    
│ │ │ │  
    The two slices returned go from the start of the string slice to mid,
│ │ │ │  and from mid to the end of the string slice.
    
│ │ │ │ -
    To get mutable string slices instead, see the split_at_mut_checked
│ │ │ │ +
    To get mutable string slices instead, see the split_at_mut_checked
│ │ │ │  method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(split_at_checked)]
│ │ │ │  
│ │ │ │  let s = "Per Martin-Löf";
│ │ │ │  
│ │ │ │  let (first, last) = s.split_at_checked(3).unwrap();
│ │ │ │  assert_eq!("Per", first);
│ │ │ │  assert_eq!(" Martin-Löf", last);
│ │ │ │  
│ │ │ │  assert_eq!(None, s.split_at_checked(13));  // Inside “ö”
│ │ │ │  assert_eq!(None, s.split_at_checked(16));  // Beyond the string length
    Run
    
│ │ │ │ -
    source
    pub fn split_at_mut_checked(
│ │ │ │ +
    source
    pub fn split_at_mut_checked(
│ │ │ │      &mut self,
│ │ │ │ -    mid: usize
│ │ │ │ -) -> Option<(&mut str, &mut str)>
    🔬This is a nightly-only experimental API. (split_at_checked #119128)
    Divide one mutable string slice into two at an index.
    
│ │ │ │ +    mid: usize
│ │ │ │ +) -> Option<(&mut str, &mut str)>
    🔬This is a nightly-only experimental API. (split_at_checked #119128)
    Divide one mutable string slice into two at an index.
    
│ │ │ │  
    The argument, mid, should be a valid byte offset from the start of the
│ │ │ │  string. It must also be on the boundary of a UTF-8 code point. The
│ │ │ │  method returns None if that’s not the case.
    
│ │ │ │  
    The two slices returned go from the start of the string slice to mid,
│ │ │ │  and from mid to the end of the string slice.
    
│ │ │ │ -
    To get immutable string slices instead, see the split_at_checked method.
    
│ │ │ │ +
    To get immutable string slices instead, see the split_at_checked method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(split_at_checked)]
│ │ │ │  
│ │ │ │  let mut s = "Per Martin-Löf".to_string();
│ │ │ │  if let Some((first, last)) = s.split_at_mut_checked(3) {
│ │ │ │      first.make_ascii_uppercase();
│ │ │ │      assert_eq!("PER", first);
│ │ │ │      assert_eq!(" Martin-Löf", last);
│ │ │ │  }
│ │ │ │  assert_eq!("PER Martin-Löf", s);
│ │ │ │  
│ │ │ │  assert_eq!(None, s.split_at_mut_checked(13));  // Inside “ö”
│ │ │ │  assert_eq!(None, s.split_at_mut_checked(16));  // Beyond the string length
    Run
    
│ │ │ │ -
    source
    pub fn chars(&self) -> Chars<'_> ⓘ
    Returns an iterator over the chars of a string slice.
    
│ │ │ │ +
    source
    pub fn chars(&self) -> Chars<'_> ⓘ
    Returns an iterator over the chars of a string slice.
    
│ │ │ │  
    As a string slice consists of valid UTF-8, we can iterate through a
│ │ │ │ -string slice by char. This method returns such an iterator.
    
│ │ │ │ -
    It’s important to remember that char represents a Unicode Scalar
│ │ │ │ +string slice by char. This method returns such an iterator.
    
│ │ │ │ +
    It’s important to remember that char represents a Unicode Scalar
│ │ │ │  Value, and might not match your idea of what a ‘character’ is. Iteration
│ │ │ │  over grapheme clusters may be what you actually want. This functionality
│ │ │ │  is not provided by Rust’s standard library, check crates.io instead.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    let word = "goodbye";
│ │ │ │ @@ -1344,30 +1344,30 @@
│ │ │ │  assert_eq!(Some('o'), chars.next());
│ │ │ │  assert_eq!(Some('d'), chars.next());
│ │ │ │  assert_eq!(Some('b'), chars.next());
│ │ │ │  assert_eq!(Some('y'), chars.next());
│ │ │ │  assert_eq!(Some('e'), chars.next());
│ │ │ │  
│ │ │ │  assert_eq!(None, chars.next());
    Run
    
│ │ │ │ -
    Remember, chars might not match your intuition about characters:
    
│ │ │ │ +
    Remember, chars might not match your intuition about characters:
    
│ │ │ │  
│ │ │ │  
    let y = "y̆";
│ │ │ │  
│ │ │ │  let mut chars = y.chars();
│ │ │ │  
│ │ │ │  assert_eq!(Some('y'), chars.next()); // not 'y̆'
│ │ │ │  assert_eq!(Some('\u{0306}'), chars.next());
│ │ │ │  
│ │ │ │  assert_eq!(None, chars.next());
    Run
    
│ │ │ │ -
    source
    pub fn char_indices(&self) -> CharIndices<'_> ⓘ
    Returns an iterator over the chars of a string slice, and their
│ │ │ │ +
    source
    pub fn char_indices(&self) -> CharIndices<'_> ⓘ
    Returns an iterator over the chars of a string slice, and their
│ │ │ │  positions.
    
│ │ │ │  
    As a string slice consists of valid UTF-8, we can iterate through a
│ │ │ │ -string slice by char. This method returns an iterator of both
│ │ │ │ -these chars, as well as their byte positions.
    
│ │ │ │ -
    The iterator yields tuples. The position is first, the char is
│ │ │ │ +string slice by char. This method returns an iterator of both
│ │ │ │ +these chars, as well as their byte positions.
    
│ │ │ │ +
    The iterator yields tuples. The position is first, the char is
│ │ │ │  second.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    let word = "goodbye";
│ │ │ │  
│ │ │ │  let count = word.char_indices().count();
│ │ │ │ @@ -1380,46 +1380,46 @@
│ │ │ │  assert_eq!(Some((2, 'o')), char_indices.next());
│ │ │ │  assert_eq!(Some((3, 'd')), char_indices.next());
│ │ │ │  assert_eq!(Some((4, 'b')), char_indices.next());
│ │ │ │  assert_eq!(Some((5, 'y')), char_indices.next());
│ │ │ │  assert_eq!(Some((6, 'e')), char_indices.next());
│ │ │ │  
│ │ │ │  assert_eq!(None, char_indices.next());
    Run
    
│ │ │ │ -
    Remember, chars might not match your intuition about characters:
    
│ │ │ │ +
    Remember, chars might not match your intuition about characters:
    
│ │ │ │  
│ │ │ │  
    let yes = "y̆es";
│ │ │ │  
│ │ │ │  let mut char_indices = yes.char_indices();
│ │ │ │  
│ │ │ │  assert_eq!(Some((0, 'y')), char_indices.next()); // not (0, 'y̆')
│ │ │ │  assert_eq!(Some((1, '\u{0306}')), char_indices.next());
│ │ │ │  
│ │ │ │  // note the 3 here - the previous character took up two bytes
│ │ │ │  assert_eq!(Some((3, 'e')), char_indices.next());
│ │ │ │  assert_eq!(Some((4, 's')), char_indices.next());
│ │ │ │  
│ │ │ │  assert_eq!(None, char_indices.next());
    Run
    
│ │ │ │ -
    source
    pub fn bytes(&self) -> Bytes<'_> ⓘ
    An iterator over the bytes of a string slice.
    
│ │ │ │ +
    source
    pub fn bytes(&self) -> Bytes<'_> ⓘ
    An iterator over the bytes of a string slice.
    
│ │ │ │  
    As a string slice consists of a sequence of bytes, we can iterate
│ │ │ │  through a string slice by byte. This method returns such an iterator.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut bytes = "bors".bytes();
│ │ │ │  
│ │ │ │  assert_eq!(Some(b'b'), bytes.next());
│ │ │ │  assert_eq!(Some(b'o'), bytes.next());
│ │ │ │  assert_eq!(Some(b'r'), bytes.next());
│ │ │ │  assert_eq!(Some(b's'), bytes.next());
│ │ │ │  
│ │ │ │  assert_eq!(None, bytes.next());
    Run
    
│ │ │ │ -
    1.1.0 · source
    pub fn split_whitespace(&self) -> SplitWhitespace<'_> ⓘ
    Splits a string slice by whitespace.
    
│ │ │ │ +
    1.1.0 · source
    pub fn split_whitespace(&self) -> SplitWhitespace<'_> ⓘ
    Splits a string slice by whitespace.
    
│ │ │ │  
    The iterator returned will return string slices that are sub-slices of
│ │ │ │  the original string slice, separated by any amount of whitespace.
    
│ │ │ │  
    ‘Whitespace’ is defined according to the terms of the Unicode Derived
│ │ │ │  Core Property White_Space. If you only want to split on ASCII whitespace
│ │ │ │ -instead, use split_ascii_whitespace.
    
│ │ │ │ +instead, use split_ascii_whitespace.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    let mut iter = "A few words".split_whitespace();
│ │ │ │  
│ │ │ │  assert_eq!(Some("A"), iter.next());
│ │ │ │  assert_eq!(Some("few"), iter.next());
│ │ │ │ @@ -1436,18 +1436,18 @@
│ │ │ │  assert_eq!(Some("lamb"), iter.next());
│ │ │ │  
│ │ │ │  assert_eq!(None, iter.next());
    Run
    
│ │ │ │  
    If the string is empty or all whitespace, the iterator yields no string slices:
    
│ │ │ │  
│ │ │ │  
    assert_eq!("".split_whitespace().next(), None);
│ │ │ │  assert_eq!("   ".split_whitespace().next(), None);
    Run
    
│ │ │ │ -
    1.34.0 · source
    pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_> ⓘ
    Splits a string slice by ASCII whitespace.
    
│ │ │ │ +
    1.34.0 · source
    pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_> ⓘ
    Splits a string slice by ASCII whitespace.
    
│ │ │ │  
    The iterator returned will return string slices that are sub-slices of
│ │ │ │  the original string slice, separated by any amount of ASCII whitespace.
    
│ │ │ │ -
    To split by Unicode Whitespace instead, use split_whitespace.
    
│ │ │ │ +
    To split by Unicode Whitespace instead, use split_whitespace.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Basic usage:
    
│ │ │ │  
│ │ │ │  
    let mut iter = "A few words".split_ascii_whitespace();
│ │ │ │  
│ │ │ │  assert_eq!(Some("A"), iter.next());
│ │ │ │  assert_eq!(Some("few"), iter.next());
│ │ │ │ @@ -1464,15 +1464,15 @@
│ │ │ │  assert_eq!(Some("lamb"), iter.next());
│ │ │ │  
│ │ │ │  assert_eq!(None, iter.next());
    Run
    
│ │ │ │  
    If the string is empty or all ASCII whitespace, the iterator yields no string slices:
    
│ │ │ │  
│ │ │ │  
    assert_eq!("".split_ascii_whitespace().next(), None);
│ │ │ │  assert_eq!("   ".split_ascii_whitespace().next(), None);
    Run
    
│ │ │ │ -
    source
    pub fn lines(&self) -> Lines<'_> ⓘ
    An iterator over the lines of a string, as string slices.
    
│ │ │ │ +
    source
    pub fn lines(&self) -> Lines<'_> ⓘ
    An iterator over the lines of a string, as string slices.
    
│ │ │ │  
    Lines are split at line endings that are either newlines (\n) or
│ │ │ │  sequences of a carriage return followed by a line feed (\r\n).
    
│ │ │ │  
    Line terminators are not included in the lines returned by the iterator.
    
│ │ │ │  
    Note that any carriage return (\r) not immediately followed by a
│ │ │ │  line feed (\n) does not split a line. These carriage returns are
│ │ │ │  thereby included in the produced lines.
    
│ │ │ │  
    The final line ending is optional. A string that ends with a final line
│ │ │ │ @@ -1498,72 +1498,72 @@
│ │ │ │  
│ │ │ │  assert_eq!(Some("foo"), lines.next());
│ │ │ │  assert_eq!(Some("bar"), lines.next());
│ │ │ │  assert_eq!(Some(""), lines.next());
│ │ │ │  assert_eq!(Some("baz"), lines.next());
│ │ │ │  
│ │ │ │  assert_eq!(None, lines.next());Run
    
│ │ │ │ -
    source
    pub fn lines_any(&self) -> LinesAny<'_> ⓘ
    👎Deprecated since 1.4.0: use lines() instead now
    An iterator over the lines of a string.
    
│ │ │ │ -
    1.8.0 · source
    pub fn encode_utf16(&self) -> EncodeUtf16<'_> ⓘ
    Returns an iterator of u16 over the string encoded as UTF-16.
    
│ │ │ │ +
    source
    pub fn lines_any(&self) -> LinesAny<'_> ⓘ
    👎Deprecated since 1.4.0: use lines() instead now
    An iterator over the lines of a string.
    
│ │ │ │ +
    1.8.0 · source
    pub fn encode_utf16(&self) -> EncodeUtf16<'_> ⓘ
    Returns an iterator of u16 over the string encoded as UTF-16.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let text = "Zażółć gęślą jaźń";
│ │ │ │  
│ │ │ │  let utf8_len = text.len();
│ │ │ │  let utf16_len = text.encode_utf16().count();
│ │ │ │  
│ │ │ │  assert!(utf16_len <= utf8_len);
    Run
    
│ │ │ │ -
    source
    pub fn contains<'a, P>(&'a self, pat: P) -> bool
    where
│ │ │ │ +
    source
    pub fn contains<'a, P>(&'a self, pat: P) -> bool
    where
│ │ │ │      P: Pattern<'a>,
    Returns true if the given pattern matches a sub-slice of
│ │ │ │  this string slice.
    
│ │ │ │  
    Returns false if it does not.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let bananas = "bananas";
│ │ │ │  
│ │ │ │  assert!(bananas.contains("nana"));
│ │ │ │  assert!(!bananas.contains("apples"));
    Run
    
│ │ │ │ -
    source
    pub fn starts_with<'a, P>(&'a self, pat: P) -> bool
    where
│ │ │ │ +
    source
    pub fn starts_with<'a, P>(&'a self, pat: P) -> bool
    where
│ │ │ │      P: Pattern<'a>,
    Returns true if the given pattern matches a prefix of this
│ │ │ │  string slice.
    
│ │ │ │  
    Returns false if it does not.
    
│ │ │ │  
    The pattern can be a &str, in which case this function will return true if
│ │ │ │  the &str is a prefix of this string slice.
    
│ │ │ │ -
    The pattern can also be a char, a slice of chars, or a
│ │ │ │ +
    The pattern can also be a char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
│ │ │ │  These will only be checked against the first character of this string slice.
│ │ │ │ -Look at the second example below regarding behavior for slices of chars.
    
│ │ │ │ +Look at the second example below regarding behavior for slices of chars.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let bananas = "bananas";
│ │ │ │  
│ │ │ │  assert!(bananas.starts_with("bana"));
│ │ │ │  assert!(!bananas.starts_with("nana"));
    Run
    
│ │ │ │  
│ │ │ │  
    let bananas = "bananas";
│ │ │ │  
│ │ │ │  // Note that both of these assert successfully.
│ │ │ │  assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
│ │ │ │  assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
    Run
    
│ │ │ │ -
    source
    pub fn ends_with<'a, P>(&'a self, pat: P) -> bool
    where
│ │ │ │ +
    source
    pub fn ends_with<'a, P>(&'a self, pat: P) -> bool
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Returns true if the given pattern matches a suffix of this
│ │ │ │  string slice.
    
│ │ │ │  
    Returns false if it does not.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let bananas = "bananas";
│ │ │ │  
│ │ │ │  assert!(bananas.ends_with("anas"));
│ │ │ │  assert!(!bananas.ends_with("nana"));
    Run
    
│ │ │ │ -
    source
    pub fn find<'a, P>(&'a self, pat: P) -> Option<usize>
    where
│ │ │ │ +
    source
    pub fn find<'a, P>(&'a self, pat: P) -> Option<usize>
    where
│ │ │ │      P: Pattern<'a>,
    Returns the byte index of the first character of this string slice that
│ │ │ │  matches the pattern.
    
│ │ │ │ -
    Returns None if the pattern doesn’t match.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    Returns None if the pattern doesn’t match.
    
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Simple patterns:
    
│ │ │ │  
│ │ │ │  
    let s = "Löwe 老虎 Léopard Gepardi";
│ │ │ │  
│ │ │ │  assert_eq!(s.find('L'), Some(0));
│ │ │ │ @@ -1579,20 +1579,20 @@
│ │ │ │  assert_eq!(s.find(|c: char| (c < 'o') && (c > 'a')), Some(4));
    Run
    
│ │ │ │  
    Not finding the pattern:
    
│ │ │ │  
│ │ │ │  
    let s = "Löwe 老虎 Léopard";
│ │ │ │  let x: &[_] = &['1', '2'];
│ │ │ │  
│ │ │ │  assert_eq!(s.find(x), None);
    Run
    
│ │ │ │ -
    source
    pub fn rfind<'a, P>(&'a self, pat: P) -> Option<usize>
    where
│ │ │ │ +
    source
    pub fn rfind<'a, P>(&'a self, pat: P) -> Option<usize>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Returns the byte index for the first character of the last match of the pattern in
│ │ │ │  this string slice.
    
│ │ │ │ -
    Returns None if the pattern doesn’t match.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    Returns None if the pattern doesn’t match.
    
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Simple patterns:
    
│ │ │ │  
│ │ │ │  
    let s = "Löwe 老虎 Léopard Gepardi";
│ │ │ │  
│ │ │ │  assert_eq!(s.rfind('L'), Some(13));
│ │ │ │ @@ -1606,25 +1606,25 @@
│ │ │ │  assert_eq!(s.rfind(char::is_lowercase), Some(20));
    Run
    
│ │ │ │  
    Not finding the pattern:
    
│ │ │ │  
│ │ │ │  
    let s = "Löwe 老虎 Léopard";
│ │ │ │  let x: &[_] = &['1', '2'];
│ │ │ │  
│ │ │ │  assert_eq!(s.rfind(x), None);
    Run
    
│ │ │ │ -
    source
    pub fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> ⓘ
    where
│ │ │ │ +
    source
    pub fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> ⓘ
    where
│ │ │ │      P: Pattern<'a>,
    An iterator over substrings of this string slice, separated by
│ │ │ │  characters matched by a pattern.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Iterator behavior
    
│ │ │ │ -
    The returned iterator will be a DoubleEndedIterator if the pattern
│ │ │ │ +
    The returned iterator will be a DoubleEndedIterator if the pattern
│ │ │ │  allows a reverse search and forward/reverse search yields the same
│ │ │ │ -elements. This is true for, e.g., char, but not for &str.
    
│ │ │ │ +elements. This is true for, e.g., char, but not for &str.
    
│ │ │ │  
    If the pattern allows a reverse search but its results might differ
│ │ │ │ -from a forward search, the rsplit method can be used.
    
│ │ │ │ +from a forward search, the rsplit method can be used.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Simple patterns:
    
│ │ │ │  
│ │ │ │  
    let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
│ │ │ │  assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "".split('X').collect();
│ │ │ │ @@ -1679,44 +1679,44 @@
│ │ │ │  
    let x = "    a  b c".to_string();
│ │ │ │  let d: Vec<_> = x.split(' ').collect();
│ │ │ │  
│ │ │ │  assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
    Run
    
│ │ │ │  
    It does not give you:
    
│ │ │ │  
│ │ │ │  
    ⓘ
    assert_eq!(d, &["a", "b", "c"]);
    Run
    
│ │ │ │ -
    Use split_whitespace for this behavior.
    
│ │ │ │ -
    1.51.0 · source
    pub fn split_inclusive<'a, P>(&'a self, pat: P) -> SplitInclusive<'a, P> ⓘ
    where
│ │ │ │ +
    Use split_whitespace for this behavior.
    
│ │ │ │ +
    1.51.0 · source
    pub fn split_inclusive<'a, P>(&'a self, pat: P) -> SplitInclusive<'a, P> ⓘ
    where
│ │ │ │      P: Pattern<'a>,
    An iterator over substrings of this string slice, separated by
│ │ │ │  characters matched by a pattern. Differs from the iterator produced by
│ │ │ │  split in that split_inclusive leaves the matched part as the
│ │ │ │  terminator of the substring.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb."
│ │ │ │      .split_inclusive('\n').collect();
│ │ │ │  assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);
    Run
    
│ │ │ │  
    If the last element of the string is matched,
│ │ │ │  that element will be considered the terminator of the preceding substring.
│ │ │ │  That substring will be the last item returned by the iterator.
    
│ │ │ │  
│ │ │ │  
    let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb.\n"
│ │ │ │      .split_inclusive('\n').collect();
│ │ │ │  assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb.\n"]);
    Run
    
│ │ │ │ -
    source
    pub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> ⓘ
    where
│ │ │ │ +
    source
    pub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> ⓘ
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    An iterator over substrings of the given string slice, separated by
│ │ │ │  characters matched by a pattern and yielded in reverse order.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Iterator behavior
    
│ │ │ │  
    The returned iterator requires that the pattern supports a reverse
│ │ │ │ -search, and it will be a DoubleEndedIterator if a forward/reverse
│ │ │ │ +search, and it will be a DoubleEndedIterator if a forward/reverse
│ │ │ │  search yields the same elements.
    
│ │ │ │ -
    For iterating from the front, the split method can be used.
    
│ │ │ │ +
    For iterating from the front, the split method can be used.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Simple patterns:
    
│ │ │ │  
│ │ │ │  
    let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect();
│ │ │ │  assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]);
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "".rsplit('X').collect();
│ │ │ │ @@ -1727,74 +1727,74 @@
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect();
│ │ │ │  assert_eq!(v, ["leopard", "tiger", "lion"]);
    Run
    
│ │ │ │  
    A more complex pattern, using a closure:
    
│ │ │ │  
│ │ │ │  
    let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect();
│ │ │ │  assert_eq!(v, ["ghi", "def", "abc"]);
    Run
    
│ │ │ │ -
    source
    pub fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> ⓘ
    where
│ │ │ │ +
    source
    pub fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> ⓘ
    where
│ │ │ │      P: Pattern<'a>,
    An iterator over substrings of the given string slice, separated by
│ │ │ │  characters matched by a pattern.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │ -
    Equivalent to split, except that the trailing substring
│ │ │ │ +
    Equivalent to split, except that the trailing substring
│ │ │ │  is skipped if empty.
    
│ │ │ │  
    This method can be used for string data that is terminated,
│ │ │ │  rather than separated by a pattern.
    
│ │ │ │  
    §Iterator behavior
    
│ │ │ │ -
    The returned iterator will be a DoubleEndedIterator if the pattern
│ │ │ │ +
    The returned iterator will be a DoubleEndedIterator if the pattern
│ │ │ │  allows a reverse search and forward/reverse search yields the same
│ │ │ │ -elements. This is true for, e.g., char, but not for &str.
    
│ │ │ │ +elements. This is true for, e.g., char, but not for &str.
    
│ │ │ │  
    If the pattern allows a reverse search but its results might differ
│ │ │ │ -from a forward search, the rsplit_terminator method can be used.
    
│ │ │ │ +from a forward search, the rsplit_terminator method can be used.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let v: Vec<&str> = "A.B.".split_terminator('.').collect();
│ │ │ │  assert_eq!(v, ["A", "B"]);
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "A..B..".split_terminator(".").collect();
│ │ │ │  assert_eq!(v, ["A", "", "B", ""]);
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "A.B:C.D".split_terminator(&['.', ':'][..]).collect();
│ │ │ │  assert_eq!(v, ["A", "B", "C", "D"]);
    Run
    
│ │ │ │ -
    source
    pub fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> ⓘ
    where
│ │ │ │ +
    source
    pub fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> ⓘ
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    An iterator over substrings of self, separated by characters
│ │ │ │  matched by a pattern and yielded in reverse order.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │ -
    Equivalent to split, except that the trailing substring is
│ │ │ │ +
    Equivalent to split, except that the trailing substring is
│ │ │ │  skipped if empty.
    
│ │ │ │  
    This method can be used for string data that is terminated,
│ │ │ │  rather than separated by a pattern.
    
│ │ │ │  
    §Iterator behavior
    
│ │ │ │  
    The returned iterator requires that the pattern supports a
│ │ │ │  reverse search, and it will be double ended if a forward/reverse
│ │ │ │  search yields the same elements.
    
│ │ │ │ -
    For iterating from the front, the split_terminator method can be
│ │ │ │ +
    For iterating from the front, the split_terminator method can be
│ │ │ │  used.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect();
│ │ │ │  assert_eq!(v, ["B", "A"]);
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect();
│ │ │ │  assert_eq!(v, ["", "B", "", "A"]);
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "A.B:C.D".rsplit_terminator(&['.', ':'][..]).collect();
│ │ │ │  assert_eq!(v, ["D", "C", "B", "A"]);
    Run
    
│ │ │ │ -
    source
    pub fn splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P> ⓘ
    where
│ │ │ │ +
    source
    pub fn splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P> ⓘ
    where
│ │ │ │      P: Pattern<'a>,
    An iterator over substrings of the given string slice, separated by a
│ │ │ │  pattern, restricted to returning at most n items.
    
│ │ │ │  
    If n substrings are returned, the last substring (the nth substring)
│ │ │ │  will contain the remainder of the string.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Iterator behavior
    
│ │ │ │  
    The returned iterator will not be double ended, because it is
│ │ │ │  not efficient to support.
    
│ │ │ │ -
    If the pattern allows a reverse search, the rsplitn method can be
│ │ │ │ +
    If the pattern allows a reverse search, the rsplitn method can be
│ │ │ │  used.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Simple patterns:
    
│ │ │ │  
│ │ │ │  
    let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect();
│ │ │ │  assert_eq!(v, ["Mary", "had", "a little lambda"]);
│ │ │ │  
│ │ │ │ @@ -1806,27 +1806,27 @@
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "".splitn(1, 'X').collect();
│ │ │ │  assert_eq!(v, [""]);
    Run
    
│ │ │ │  
    A more complex pattern, using a closure:
    
│ │ │ │  
│ │ │ │  
    let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect();
│ │ │ │  assert_eq!(v, ["abc", "defXghi"]);
    Run
    
│ │ │ │ -
    source
    pub fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> ⓘ
    where
│ │ │ │ +
    source
    pub fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> ⓘ
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    An iterator over substrings of this string slice, separated by a
│ │ │ │  pattern, starting from the end of the string, restricted to returning
│ │ │ │  at most n items.
    
│ │ │ │  
    If n substrings are returned, the last substring (the nth substring)
│ │ │ │  will contain the remainder of the string.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Iterator behavior
    
│ │ │ │  
    The returned iterator will not be double ended, because it is not
│ │ │ │  efficient to support.
    
│ │ │ │ -
    For splitting from the front, the splitn method can be used.
    
│ │ │ │ +
    For splitting from the front, the splitn method can be used.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Simple patterns:
    
│ │ │ │  
│ │ │ │  
    let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
│ │ │ │  assert_eq!(v, ["lamb", "little", "Mary had a"]);
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();
│ │ │ │ @@ -1834,116 +1834,116 @@
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();
│ │ │ │  assert_eq!(v, ["leopard", "lion::tiger"]);
    Run
    
│ │ │ │  
    A more complex pattern, using a closure:
    
│ │ │ │  
│ │ │ │  
    let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
│ │ │ │  assert_eq!(v, ["ghi", "abc1def"]);
    Run
    
│ │ │ │ -
    1.52.0 · source
    pub fn split_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)>
    where
│ │ │ │ +
    1.52.0 · source
    pub fn split_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)>
    where
│ │ │ │      P: Pattern<'a>,
    Splits the string on the first occurrence of the specified delimiter and
│ │ │ │  returns prefix before delimiter and suffix after delimiter.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("cfg".split_once('='), None);
│ │ │ │  assert_eq!("cfg=".split_once('='), Some(("cfg", "")));
│ │ │ │  assert_eq!("cfg=foo".split_once('='), Some(("cfg", "foo")));
│ │ │ │  assert_eq!("cfg=foo=bar".split_once('='), Some(("cfg", "foo=bar")));
    Run
    
│ │ │ │ -
    1.52.0 · source
    pub fn rsplit_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)>
    where
│ │ │ │ +
    1.52.0 · source
    pub fn rsplit_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Splits the string on the last occurrence of the specified delimiter and
│ │ │ │  returns prefix before delimiter and suffix after delimiter.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("cfg".rsplit_once('='), None);
│ │ │ │  assert_eq!("cfg=foo".rsplit_once('='), Some(("cfg", "foo")));
│ │ │ │  assert_eq!("cfg=foo=bar".rsplit_once('='), Some(("cfg=foo", "bar")));
    Run
    
│ │ │ │ -
    1.2.0 · source
    pub fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> ⓘ
    where
│ │ │ │ +
    1.2.0 · source
    pub fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> ⓘ
    where
│ │ │ │      P: Pattern<'a>,
    An iterator over the disjoint matches of a pattern within the given string
│ │ │ │  slice.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Iterator behavior
    
│ │ │ │ -
    The returned iterator will be a DoubleEndedIterator if the pattern
│ │ │ │ +
    The returned iterator will be a DoubleEndedIterator if the pattern
│ │ │ │  allows a reverse search and forward/reverse search yields the same
│ │ │ │ -elements. This is true for, e.g., char, but not for &str.
    
│ │ │ │ +elements. This is true for, e.g., char, but not for &str.
    
│ │ │ │  
    If the pattern allows a reverse search but its results might differ
│ │ │ │ -from a forward search, the rmatches method can be used.
    
│ │ │ │ +from a forward search, the rmatches method can be used.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
│ │ │ │  assert_eq!(v, ["abc", "abc", "abc"]);
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();
│ │ │ │  assert_eq!(v, ["1", "2", "3"]);
    Run
    
│ │ │ │ -
    1.2.0 · source
    pub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> ⓘ
    where
│ │ │ │ +
    1.2.0 · source
    pub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> ⓘ
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    An iterator over the disjoint matches of a pattern within this string slice,
│ │ │ │  yielded in reverse order.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Iterator behavior
    
│ │ │ │  
    The returned iterator requires that the pattern supports a reverse
│ │ │ │ -search, and it will be a DoubleEndedIterator if a forward/reverse
│ │ │ │ +search, and it will be a DoubleEndedIterator if a forward/reverse
│ │ │ │  search yields the same elements.
    
│ │ │ │ -
    For iterating from the front, the matches method can be used.
    
│ │ │ │ +
    For iterating from the front, the matches method can be used.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect();
│ │ │ │  assert_eq!(v, ["abc", "abc", "abc"]);
│ │ │ │  
│ │ │ │  let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect();
│ │ │ │  assert_eq!(v, ["3", "2", "1"]);
    Run
    
│ │ │ │ -
    1.5.0 · source
    pub fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> ⓘ
    where
│ │ │ │ +
    1.5.0 · source
    pub fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> ⓘ
    where
│ │ │ │      P: Pattern<'a>,
    An iterator over the disjoint matches of a pattern within this string
│ │ │ │  slice as well as the index that the match starts at.
    
│ │ │ │  
    For matches of pat within self that overlap, only the indices
│ │ │ │  corresponding to the first match are returned.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Iterator behavior
    
│ │ │ │ -
    The returned iterator will be a DoubleEndedIterator if the pattern
│ │ │ │ +
    The returned iterator will be a DoubleEndedIterator if the pattern
│ │ │ │  allows a reverse search and forward/reverse search yields the same
│ │ │ │ -elements. This is true for, e.g., char, but not for &str.
    
│ │ │ │ +elements. This is true for, e.g., char, but not for &str.
    
│ │ │ │  
    If the pattern allows a reverse search but its results might differ
│ │ │ │ -from a forward search, the rmatch_indices method can be used.
    
│ │ │ │ +from a forward search, the rmatch_indices method can be used.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
│ │ │ │  assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);
│ │ │ │  
│ │ │ │  let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
│ │ │ │  assert_eq!(v, [(1, "abc"), (4, "abc")]);
│ │ │ │  
│ │ │ │  let v: Vec<_> = "ababa".match_indices("aba").collect();
│ │ │ │  assert_eq!(v, [(0, "aba")]); // only the first `aba`
    Run
    
│ │ │ │ -
    1.5.0 · source
    pub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> ⓘ
    where
│ │ │ │ +
    1.5.0 · source
    pub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> ⓘ
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    An iterator over the disjoint matches of a pattern within self,
│ │ │ │  yielded in reverse order along with the index of the match.
    
│ │ │ │  
    For matches of pat within self that overlap, only the indices
│ │ │ │  corresponding to the last match are returned.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Iterator behavior
    
│ │ │ │  
    The returned iterator requires that the pattern supports a reverse
│ │ │ │ -search, and it will be a DoubleEndedIterator if a forward/reverse
│ │ │ │ +search, and it will be a DoubleEndedIterator if a forward/reverse
│ │ │ │  search yields the same elements.
    
│ │ │ │ -
    For iterating from the front, the match_indices method can be used.
    
│ │ │ │ +
    For iterating from the front, the match_indices method can be used.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
│ │ │ │  assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);
│ │ │ │  
│ │ │ │  let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
│ │ │ │  assert_eq!(v, [(4, "abc"), (1, "abc")]);
│ │ │ │  
│ │ │ │  let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
│ │ │ │  assert_eq!(v, [(2, "aba")]); // only the last `aba`
    Run
    
│ │ │ │ -
    source
    pub fn trim(&self) -> &str
    Returns a string slice with leading and trailing whitespace removed.
    
│ │ │ │ +
    source
    pub fn trim(&self) -> &str
    Returns a string slice with leading and trailing whitespace removed.
    
│ │ │ │  
    ‘Whitespace’ is defined according to the terms of the Unicode Derived
│ │ │ │  Core Property White_Space, which includes newlines.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s = "\n Hello\tworld\t\n";
│ │ │ │  
│ │ │ │  assert_eq!("Hello\tworld", s.trim());
    Run
    
│ │ │ │ -
    1.30.0 · source
    pub fn trim_start(&self) -> &str
    Returns a string slice with leading whitespace removed.
    
│ │ │ │ +
    1.30.0 · source
    pub fn trim_start(&self) -> &str
    Returns a string slice with leading whitespace removed.
    
│ │ │ │  
    ‘Whitespace’ is defined according to the terms of the Unicode Derived
│ │ │ │  Core Property White_Space, which includes newlines.
    
│ │ │ │  
    §Text directionality
    
│ │ │ │  
    A string is a sequence of bytes. start in this context means the first
│ │ │ │  position of that byte string; for a left-to-right language like English or
│ │ │ │  Russian, this will be left side, and for right-to-left languages like
│ │ │ │  Arabic or Hebrew, this will be the right side.
    
│ │ │ │ @@ -1955,15 +1955,15 @@
│ │ │ │  
    Directionality:
    
│ │ │ │  
│ │ │ │  
    let s = "  English  ";
│ │ │ │  assert!(Some('E') == s.trim_start().chars().next());
│ │ │ │  
│ │ │ │  let s = "  עברית  ";
│ │ │ │  assert!(Some('ע') == s.trim_start().chars().next());
    Run
    
│ │ │ │ -
    1.30.0 · source
    pub fn trim_end(&self) -> &str
    Returns a string slice with trailing whitespace removed.
    
│ │ │ │ +
    1.30.0 · source
    pub fn trim_end(&self) -> &str
    Returns a string slice with trailing whitespace removed.
    
│ │ │ │  
    ‘Whitespace’ is defined according to the terms of the Unicode Derived
│ │ │ │  Core Property White_Space, which includes newlines.
    
│ │ │ │  
    §Text directionality
    
│ │ │ │  
    A string is a sequence of bytes. end in this context means the last
│ │ │ │  position of that byte string; for a left-to-right language like English or
│ │ │ │  Russian, this will be right side, and for right-to-left languages like
│ │ │ │  Arabic or Hebrew, this will be the left side.
    
│ │ │ │ @@ -1975,15 +1975,15 @@
│ │ │ │  
    Directionality:
    
│ │ │ │  
│ │ │ │  
    let s = "  English  ";
│ │ │ │  assert!(Some('h') == s.trim_end().chars().rev().next());
│ │ │ │  
│ │ │ │  let s = "  עברית  ";
│ │ │ │  assert!(Some('ת') == s.trim_end().chars().rev().next());
    Run
    
│ │ │ │ -
    source
    pub fn trim_left(&self) -> &str
    👎Deprecated since 1.33.0: superseded by trim_start
    Returns a string slice with leading whitespace removed.
    
│ │ │ │ +
    source
    pub fn trim_left(&self) -> &str
    👎Deprecated since 1.33.0: superseded by trim_start
    Returns a string slice with leading whitespace removed.
    
│ │ │ │  
    ‘Whitespace’ is defined according to the terms of the Unicode Derived
│ │ │ │  Core Property White_Space.
    
│ │ │ │  
    §Text directionality
    
│ │ │ │  
    A string is a sequence of bytes. ‘Left’ in this context means the first
│ │ │ │  position of that byte string; for a language like Arabic or Hebrew
│ │ │ │  which are ‘right to left’ rather than ‘left to right’, this will be
│ │ │ │  the right side, not the left.
    
│ │ │ │ @@ -1996,15 +1996,15 @@
│ │ │ │  
    Directionality:
    
│ │ │ │  
│ │ │ │  
    let s = "  English";
│ │ │ │  assert!(Some('E') == s.trim_left().chars().next());
│ │ │ │  
│ │ │ │  let s = "  עברית";
│ │ │ │  assert!(Some('ע') == s.trim_left().chars().next());
    Run
    
│ │ │ │ -
    source
    pub fn trim_right(&self) -> &str
    👎Deprecated since 1.33.0: superseded by trim_end
    Returns a string slice with trailing whitespace removed.
    
│ │ │ │ +
    source
    pub fn trim_right(&self) -> &str
    👎Deprecated since 1.33.0: superseded by trim_end
    Returns a string slice with trailing whitespace removed.
    
│ │ │ │  
    ‘Whitespace’ is defined according to the terms of the Unicode Derived
│ │ │ │  Core Property White_Space.
    
│ │ │ │  
    §Text directionality
    
│ │ │ │  
    A string is a sequence of bytes. ‘Right’ in this context means the last
│ │ │ │  position of that byte string; for a language like Arabic or Hebrew
│ │ │ │  which are ‘right to left’ rather than ‘left to right’, this will be
│ │ │ │  the left side, not the right.
    
│ │ │ │ @@ -2017,75 +2017,75 @@
│ │ │ │  
    Directionality:
    
│ │ │ │  
│ │ │ │  
    let s = "English  ";
│ │ │ │  assert!(Some('h') == s.trim_right().chars().rev().next());
│ │ │ │  
│ │ │ │  let s = "עברית  ";
│ │ │ │  assert!(Some('ת') == s.trim_right().chars().rev().next());
    Run
    
│ │ │ │ -
    source
    pub fn trim_matches<'a, P>(&'a self, pat: P) -> &'a str
    where
│ │ │ │ +
    source
    pub fn trim_matches<'a, P>(&'a self, pat: P) -> &'a str
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
    Returns a string slice with all prefixes and suffixes that match a
│ │ │ │  pattern repeatedly removed.
    
│ │ │ │ -
    The pattern can be a char, a slice of chars, or a function
│ │ │ │ +
    The pattern can be a char, a slice of chars, or a function
│ │ │ │  or closure that determines if a character matches.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Simple patterns:
    
│ │ │ │  
│ │ │ │  
    assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
│ │ │ │  assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar");
│ │ │ │  
│ │ │ │  let x: &[_] = &['1', '2'];
│ │ │ │  assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");
    Run
    
│ │ │ │  
    A more complex pattern, using a closure:
    
│ │ │ │  
│ │ │ │  
    assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");
    Run
    
│ │ │ │ -
    1.30.0 · source
    pub fn trim_start_matches<'a, P>(&'a self, pat: P) -> &'a str
    where
│ │ │ │ +
    1.30.0 · source
    pub fn trim_start_matches<'a, P>(&'a self, pat: P) -> &'a str
    where
│ │ │ │      P: Pattern<'a>,
    Returns a string slice with all prefixes that match a pattern
│ │ │ │  repeatedly removed.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Text directionality
    
│ │ │ │  
    A string is a sequence of bytes. start in this context means the first
│ │ │ │  position of that byte string; for a left-to-right language like English or
│ │ │ │  Russian, this will be left side, and for right-to-left languages like
│ │ │ │  Arabic or Hebrew, this will be the right side.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
│ │ │ │  assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");
│ │ │ │  
│ │ │ │  let x: &[_] = &['1', '2'];
│ │ │ │  assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
    Run
    
│ │ │ │ -
    1.45.0 · source
    pub fn strip_prefix<'a, P>(&'a self, prefix: P) -> Option<&'a str>
    where
│ │ │ │ +
    1.45.0 · source
    pub fn strip_prefix<'a, P>(&'a self, prefix: P) -> Option<&'a str>
    where
│ │ │ │      P: Pattern<'a>,
    Returns a string slice with the prefix removed.
    
│ │ │ │  
    If the string starts with the pattern prefix, returns the substring after the prefix,
│ │ │ │  wrapped in Some. Unlike trim_start_matches, this method removes the prefix exactly once.
    
│ │ │ │  
    If the string does not start with prefix, returns None.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));
│ │ │ │  assert_eq!("foo:bar".strip_prefix("bar"), None);
│ │ │ │  assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));
    Run
    
│ │ │ │ -
    1.45.0 · source
    pub fn strip_suffix<'a, P>(&'a self, suffix: P) -> Option<&'a str>
    where
│ │ │ │ +
    1.45.0 · source
    pub fn strip_suffix<'a, P>(&'a self, suffix: P) -> Option<&'a str>
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Returns a string slice with the suffix removed.
    
│ │ │ │  
    If the string ends with the pattern suffix, returns the substring before the suffix,
│ │ │ │  wrapped in Some.  Unlike trim_end_matches, this method removes the suffix exactly once.
    
│ │ │ │  
    If the string does not end with suffix, returns None.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("bar:foo".strip_suffix(":foo"), Some("bar"));
│ │ │ │  assert_eq!("bar:foo".strip_suffix("bar"), None);
│ │ │ │  assert_eq!("foofoo".strip_suffix("foo"), Some("foo"));
    Run
    
│ │ │ │ -
    1.30.0 · source
    pub fn trim_end_matches<'a, P>(&'a self, pat: P) -> &'a str
    where
│ │ │ │ +
    1.30.0 · source
    pub fn trim_end_matches<'a, P>(&'a self, pat: P) -> &'a str
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    Returns a string slice with all suffixes that match a pattern
│ │ │ │  repeatedly removed.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Text directionality
    
│ │ │ │  
    A string is a sequence of bytes. end in this context means the last
│ │ │ │  position of that byte string; for a left-to-right language like English or
│ │ │ │  Russian, this will be right side, and for right-to-left languages like
│ │ │ │  Arabic or Hebrew, this will be the left side.
    
│ │ │ │  
    §Examples
    
│ │ │ │ @@ -2095,35 +2095,35 @@
│ │ │ │  assert_eq!("123foo1bar123".trim_end_matches(char::is_numeric), "123foo1bar");
│ │ │ │  
│ │ │ │  let x: &[_] = &['1', '2'];
│ │ │ │  assert_eq!("12foo1bar12".trim_end_matches(x), "12foo1bar");    Run
    
│ │ │ │  
    A more complex pattern, using a closure:
    
│ │ │ │  
│ │ │ │  
    assert_eq!("1fooX".trim_end_matches(|c| c == '1' || c == 'X'), "1foo");
    Run
    
│ │ │ │ -
    source
    pub fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str
    where
│ │ │ │ +
    source
    pub fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str
    where
│ │ │ │      P: Pattern<'a>,
    👎Deprecated since 1.33.0: superseded by trim_start_matches
    Returns a string slice with all prefixes that match a pattern
│ │ │ │  repeatedly removed.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Text directionality
    
│ │ │ │  
    A string is a sequence of bytes. ‘Left’ in this context means the first
│ │ │ │  position of that byte string; for a language like Arabic or Hebrew
│ │ │ │  which are ‘right to left’ rather than ‘left to right’, this will be
│ │ │ │  the right side, not the left.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
│ │ │ │  assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123");
│ │ │ │  
│ │ │ │  let x: &[_] = &['1', '2'];
│ │ │ │  assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");
    Run
    
│ │ │ │ -
    source
    pub fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str
    where
│ │ │ │ +
    source
    pub fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str
    where
│ │ │ │      P: Pattern<'a>,
│ │ │ │      <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
    👎Deprecated since 1.33.0: superseded by trim_end_matches
    Returns a string slice with all suffixes that match a pattern
│ │ │ │  repeatedly removed.
    
│ │ │ │ -
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │ +
    The pattern can be a &str, char, a slice of chars, or a
│ │ │ │  function or closure that determines if a character matches.
    
│ │ │ │  
    §Text directionality
    
│ │ │ │  
    A string is a sequence of bytes. ‘Right’ in this context means the last
│ │ │ │  position of that byte string; for a language like Arabic or Hebrew
│ │ │ │  which are ‘right to left’ rather than ‘left to right’, this will be
│ │ │ │  the left side, not the right.
    
│ │ │ │  
    §Examples
    
│ │ │ │ @@ -2133,15 +2133,15 @@
│ │ │ │  assert_eq!("123foo1bar123".trim_right_matches(char::is_numeric), "123foo1bar");
│ │ │ │  
│ │ │ │  let x: &[_] = &['1', '2'];
│ │ │ │  assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");Run
    
│ │ │ │  
    A more complex pattern, using a closure:
    
│ │ │ │  
│ │ │ │  
    assert_eq!("1fooX".trim_right_matches(|c| c == '1' || c == 'X'), "1foo");
    Run
    
│ │ │ │ -
    source
    pub fn parse<F>(&self) -> Result<F, <F as FromStr>::Err>
    where
│ │ │ │ +
    source
    pub fn parse<F>(&self) -> Result<F, <F as FromStr>::Err>
    where
│ │ │ │      F: FromStr,
    Parses this string slice into another type.
    
│ │ │ │  
    Because parse is so general, it can cause problems with type
│ │ │ │  inference. As such, parse is one of the few times you’ll see
│ │ │ │  the syntax affectionately known as the ‘turbofish’: ::<>. This
│ │ │ │  helps the inference algorithm understand specifically which type
│ │ │ │  you’re trying to parse into.
    
│ │ │ │  
    parse can parse into any type that implements the FromStr trait.
    
│ │ │ │ @@ -2160,81 +2160,81 @@
│ │ │ │  
│ │ │ │  assert_eq!(Ok(4), four);Run
    
│ │ │ │  
    Failing to parse:
    
│ │ │ │  
│ │ │ │  
    let nope = "j".parse::<u32>();
│ │ │ │  
│ │ │ │  assert!(nope.is_err());
    Run
    
│ │ │ │ -
    1.23.0 · source
    pub fn is_ascii(&self) -> bool
    Checks if all characters in this string are within the ASCII range.
    
│ │ │ │ +
    1.23.0 · source
    pub fn is_ascii(&self) -> bool
    Checks if all characters in this string are within the ASCII range.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let ascii = "hello!\n";
│ │ │ │  let non_ascii = "Grüße, Jürgen ❤";
│ │ │ │  
│ │ │ │  assert!(ascii.is_ascii());
│ │ │ │  assert!(!non_ascii.is_ascii());
    Run
    
│ │ │ │ -
    source
    pub fn as_ascii(&self) -> Option<&[AsciiChar]>
    🔬This is a nightly-only experimental API. (ascii_char #110998)
    If this string slice is_ascii, returns it as a slice
│ │ │ │ -of ASCII characters, otherwise returns None.
    
│ │ │ │ -
    1.23.0 · source
    pub fn eq_ignore_ascii_case(&self, other: &str) -> bool
    Checks that two strings are an ASCII case-insensitive match.
    
│ │ │ │ +
    source
    pub fn as_ascii(&self) -> Option<&[AsciiChar]>
    🔬This is a nightly-only experimental API. (ascii_char #110998)
    If this string slice is_ascii, returns it as a slice
│ │ │ │ +of ASCII characters, otherwise returns None.
    
│ │ │ │ +
    1.23.0 · source
    pub fn eq_ignore_ascii_case(&self, other: &str) -> bool
    Checks that two strings are an ASCII case-insensitive match.
    
│ │ │ │  
    Same as to_ascii_lowercase(a) == to_ascii_lowercase(b),
│ │ │ │  but without allocating and copying temporaries.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert!("Ferris".eq_ignore_ascii_case("FERRIS"));
│ │ │ │  assert!("Ferrös".eq_ignore_ascii_case("FERRöS"));
│ │ │ │  assert!(!"Ferrös".eq_ignore_ascii_case("FERRÖS"));
    Run
    
│ │ │ │ -
    1.23.0 · source
    pub fn make_ascii_uppercase(&mut self)
    Converts this string to its ASCII upper case equivalent in-place.
    
│ │ │ │ +
    1.23.0 · source
    pub fn make_ascii_uppercase(&mut self)
    Converts this string to its ASCII upper case equivalent in-place.
    
│ │ │ │  
    ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’,
│ │ │ │  but non-ASCII letters are unchanged.
    
│ │ │ │  
    To return a new uppercased value without modifying the existing one, use
│ │ │ │  to_ascii_uppercase().
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("Grüße, Jürgen ❤");
│ │ │ │  
│ │ │ │  s.make_ascii_uppercase();
│ │ │ │  
│ │ │ │  assert_eq!("GRüßE, JüRGEN ❤", s);
    Run
    
│ │ │ │ -
    1.23.0 · source
    pub fn make_ascii_lowercase(&mut self)
    Converts this string to its ASCII lower case equivalent in-place.
    
│ │ │ │ +
    1.23.0 · source
    pub fn make_ascii_lowercase(&mut self)
    Converts this string to its ASCII lower case equivalent in-place.
    
│ │ │ │  
    ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’,
│ │ │ │  but non-ASCII letters are unchanged.
    
│ │ │ │  
    To return a new lowercased value without modifying the existing one, use
│ │ │ │  to_ascii_lowercase().
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut s = String::from("GRÜßE, JÜRGEN ❤");
│ │ │ │  
│ │ │ │  s.make_ascii_lowercase();
│ │ │ │  
│ │ │ │  assert_eq!("grÜße, jÜrgen ❤", s);
    Run
    
│ │ │ │ -
    source
    pub fn trim_ascii_start(&self) -> &str
    🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
    Returns a string slice with leading ASCII whitespace removed.
    
│ │ │ │ +
    source
    pub fn trim_ascii_start(&self) -> &str
    🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
    Returns a string slice with leading ASCII whitespace removed.
    
│ │ │ │  
    ‘Whitespace’ refers to the definition used by
│ │ │ │ -u8::is_ascii_whitespace.
    
│ │ │ │ +u8::is_ascii_whitespace.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(byte_slice_trim_ascii)]
│ │ │ │  
│ │ │ │  assert_eq!(" \t \u{3000}hello world\n".trim_ascii_start(), "\u{3000}hello world\n");
│ │ │ │  assert_eq!("  ".trim_ascii_start(), "");
│ │ │ │  assert_eq!("".trim_ascii_start(), "");
    Run
    
│ │ │ │ -
    source
    pub fn trim_ascii_end(&self) -> &str
    🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
    Returns a string slice with trailing ASCII whitespace removed.
    
│ │ │ │ +
    source
    pub fn trim_ascii_end(&self) -> &str
    🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
    Returns a string slice with trailing ASCII whitespace removed.
    
│ │ │ │  
    ‘Whitespace’ refers to the definition used by
│ │ │ │ -u8::is_ascii_whitespace.
    
│ │ │ │ +u8::is_ascii_whitespace.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(byte_slice_trim_ascii)]
│ │ │ │  
│ │ │ │  assert_eq!("\r hello world\u{3000}\n ".trim_ascii_end(), "\r hello world\u{3000}");
│ │ │ │  assert_eq!("  ".trim_ascii_end(), "");
│ │ │ │  assert_eq!("".trim_ascii_end(), "");
    Run
    
│ │ │ │ -
    source
    pub fn trim_ascii(&self) -> &str
    🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
    Returns a string slice with leading and trailing ASCII whitespace
│ │ │ │ +
    source
    pub fn trim_ascii(&self) -> &str
    🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
    Returns a string slice with leading and trailing ASCII whitespace
│ │ │ │  removed.
    
│ │ │ │  
    ‘Whitespace’ refers to the definition used by
│ │ │ │ -u8::is_ascii_whitespace.
    
│ │ │ │ +u8::is_ascii_whitespace.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(byte_slice_trim_ascii)]
│ │ │ │  
│ │ │ │  assert_eq!("\r hello world\n ".trim_ascii(), "hello world");
│ │ │ │  assert_eq!("  ".trim_ascii(), "");
│ │ │ │  assert_eq!("".trim_ascii(), "");
    Run
    
│ │ │ │ -
    1.34.0 · source
    pub fn escape_debug(&self) -> EscapeDebug<'_> ⓘ
    Return an iterator that escapes each char in self with char::escape_debug.
    
│ │ │ │ +
    1.34.0 · source
    pub fn escape_debug(&self) -> EscapeDebug<'_> ⓘ
    Return an iterator that escapes each char in self with char::escape_debug.
    
│ │ │ │  
    Note: only extended grapheme codepoints that begin the string will be
│ │ │ │  escaped.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    As an iterator:
    
│ │ │ │  
│ │ │ │  
    for c in "❤\n!".escape_debug() {
│ │ │ │      print!("{c}");
│ │ │ │ @@ -2245,15 +2245,15 @@
│ │ │ │  
    println!("{}", "❤\n!".escape_debug());
    Run
    
│ │ │ │  
    Both are equivalent to:
    
│ │ │ │  
│ │ │ │  
    println!("❤\\n!");
    Run
    
│ │ │ │  
    Using to_string:
    
│ │ │ │  
│ │ │ │  
    assert_eq!("❤\n!".escape_debug().to_string(), "❤\\n!");
    Run
    
│ │ │ │ -
    1.34.0 · source
    pub fn escape_default(&self) -> EscapeDefault<'_> ⓘ
    Return an iterator that escapes each char in self with char::escape_default.
    
│ │ │ │ +
    1.34.0 · source
    pub fn escape_default(&self) -> EscapeDefault<'_> ⓘ
    Return an iterator that escapes each char in self with char::escape_default.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    As an iterator:
    
│ │ │ │  
│ │ │ │  
    for c in "❤\n!".escape_default() {
│ │ │ │      print!("{c}");
│ │ │ │  }
│ │ │ │  println!();
    Run
    
│ │ │ │ @@ -2262,15 +2262,15 @@
│ │ │ │  
    println!("{}", "❤\n!".escape_default());
    Run
    
│ │ │ │  
    Both are equivalent to:
    
│ │ │ │  
│ │ │ │  
    println!("\\u{{2764}}\\n!");
    Run
    
│ │ │ │  
    Using to_string:
    
│ │ │ │  
│ │ │ │  
    assert_eq!("❤\n!".escape_default().to_string(), "\\u{2764}\\n!");
    Run
    
│ │ │ │ -
    1.34.0 · source
    pub fn escape_unicode(&self) -> EscapeUnicode<'_> ⓘ
    Return an iterator that escapes each char in self with char::escape_unicode.
    
│ │ │ │ +
    1.34.0 · source
    pub fn escape_unicode(&self) -> EscapeUnicode<'_> ⓘ
    Return an iterator that escapes each char in self with char::escape_unicode.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    As an iterator:
    
│ │ │ │  
│ │ │ │  
    for c in "❤\n!".escape_unicode() {
│ │ │ │      print!("{c}");
│ │ │ │  }
│ │ │ │  println!();
    Run
    
│ │ │ │ @@ -2279,15 +2279,15 @@
│ │ │ │  
    println!("{}", "❤\n!".escape_unicode());
    Run
    
│ │ │ │  
    Both are equivalent to:
    
│ │ │ │  
│ │ │ │  
    println!("\\u{{2764}}\\u{{a}}\\u{{21}}");
    Run
    
│ │ │ │  
    Using to_string:
    
│ │ │ │  
│ │ │ │  
    assert_eq!("❤\n!".escape_unicode().to_string(), "\\u{2764}\\u{a}\\u{21}");
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl Add<&str> for String
    Implements the + operator for concatenating two strings.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl Add<&str> for String
    Implements the + operator for concatenating two strings.
    
│ │ │ │  
    This consumes the String on the left-hand side and re-uses its buffer (growing it if
│ │ │ │  necessary). This is done to avoid allocating a new String and copying the entire contents on
│ │ │ │  every operation, which would lead to O(n^2) running time when building an n-byte string by
│ │ │ │  repeated concatenation.
    
│ │ │ │  
    The string on the right-hand side is only borrowed; its contents are copied into the returned
│ │ │ │  String.
    
│ │ │ │  
    §Examples
    
│ │ │ │ @@ -2304,135 +2304,135 @@
│ │ │ │  let c = a.clone() + &b;
│ │ │ │  // `a` is still valid here.    Run
    
│ │ │ │  
    Concatenating &str slices can be done by converting the first to a String:
    
│ │ │ │  
│ │ │ │  
    let a = "hello";
│ │ │ │  let b = " world";
│ │ │ │  let c = a.to_string() + b;
    Run
    
│ │ │ │ -
    §
    type Output = String
    The resulting type after applying the + operator.
    source§
    fn add(self, other: &str) -> String
    Performs the + operation. Read more
    1.12.0 · source§
    impl AddAssign<&str> for String
    Implements the += operator for appending to a String.
    
│ │ │ │ +
    §
    type Output = String
    The resulting type after applying the + operator.
    source§
    fn add(self, other: &str) -> String
    Performs the + operation. Read more
    1.12.0 · source§
    impl AddAssign<&str> for String
    Implements the += operator for appending to a String.
    
│ │ │ │  
    This has the same behavior as the push_str method.
    
│ │ │ │ -
    source§
    fn add_assign(&mut self, other: &str)
    Performs the += operation. Read more
    1.43.0 · source§
    impl AsMut<str> for String
    source§
    fn as_mut(&mut self) -> &mut str
    Converts this type into a mutable reference of the (usually inferred) input type.
    source§
    impl AsRef<[u8]> for String
    source§
    fn as_ref(&self) -> &[u8]
    Converts this type into a shared reference of the (usually inferred) input type.
    source§
    impl AsRef<str> for String
    source§
    fn as_ref(&self) -> &str
    Converts this type into a shared reference of the (usually inferred) input type.
    source§
    impl Borrow<str> for String
    source§
    fn borrow(&self) -> &str
    Immutably borrows from an owned value. Read more
    1.36.0 · source§
    impl BorrowMut<str> for String
    source§
    fn borrow_mut(&mut self) -> &mut str
    Mutably borrows from an owned value. Read more
    source§
    impl Clone for String
    source§
    fn clone(&self) -> Self
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for String
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl Default for String
    source§
    fn default() -> String
    Creates an empty String.
    
│ │ │ │ -
    source§
    impl Deref for String
    §
    type Target = str
    The resulting type after dereferencing.
    source§
    fn deref(&self) -> &str
    Dereferences the value.
    1.3.0 · source§
    impl DerefMut for String
    source§
    fn deref_mut(&mut self) -> &mut str
    Mutably dereferences the value.
    source§
    impl Display for String
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    1.2.0 · source§
    impl<'a> Extend<&'a char> for String
    source§
    fn extend<I: IntoIterator<Item = &'a char>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, c: &'a char)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§
    impl<'a> Extend<&'a str> for String
    source§
    fn extend<I: IntoIterator<Item = &'a str>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, s: &'a str)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.45.0 · source§
    impl Extend<Box<str>> for String
    source§
    fn extend<I: IntoIterator<Item = Box<str>>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, item: A)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.19.0 · source§
    impl<'a> Extend<Cow<'a, str>> for String
    source§
    fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, s: Cow<'a, str>)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.4.0 · source§
    impl Extend<String> for String
    source§
    fn extend<I: IntoIterator<Item = String>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, s: String)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§
    impl Extend<char> for String
    source§
    fn extend<I: IntoIterator<Item = char>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, c: char)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.28.0 · source§
    impl<'a> From<&'a String> for Cow<'a, str>
    source§
    fn from(s: &'a String) -> Cow<'a, str>
    Converts a String reference into a Borrowed variant.
│ │ │ │ +
    source§
    fn add_assign(&mut self, other: &str)
    Performs the += operation. Read more
    1.43.0 · source§
    impl AsMut<str> for String
    source§
    fn as_mut(&mut self) -> &mut str
    Converts this type into a mutable reference of the (usually inferred) input type.
    source§
    impl AsRef<[u8]> for String
    source§
    fn as_ref(&self) -> &[u8]
    Converts this type into a shared reference of the (usually inferred) input type.
    source§
    impl AsRef<str> for String
    source§
    fn as_ref(&self) -> &str
    Converts this type into a shared reference of the (usually inferred) input type.
    source§
    impl Borrow<str> for String
    source§
    fn borrow(&self) -> &str
    Immutably borrows from an owned value. Read more
    1.36.0 · source§
    impl BorrowMut<str> for String
    source§
    fn borrow_mut(&mut self) -> &mut str
    Mutably borrows from an owned value. Read more
    source§
    impl Clone for String
    source§
    fn clone(&self) -> Self
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl Debug for String
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl Default for String
    source§
    fn default() -> String
    Creates an empty String.
    
│ │ │ │ +
    source§
    impl Deref for String
    §
    type Target = str
    The resulting type after dereferencing.
    source§
    fn deref(&self) -> &str
    Dereferences the value.
    1.3.0 · source§
    impl DerefMut for String
    source§
    fn deref_mut(&mut self) -> &mut str
    Mutably dereferences the value.
    source§
    impl Display for String
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    1.2.0 · source§
    impl<'a> Extend<&'a char> for String
    source§
    fn extend<I: IntoIterator<Item = &'a char>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, c: &'a char)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§
    impl<'a> Extend<&'a str> for String
    source§
    fn extend<I: IntoIterator<Item = &'a str>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, s: &'a str)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.45.0 · source§
    impl Extend<Box<str>> for String
    source§
    fn extend<I: IntoIterator<Item = Box<str>>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, item: A)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.19.0 · source§
    impl<'a> Extend<Cow<'a, str>> for String
    source§
    fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, s: Cow<'a, str>)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.4.0 · source§
    impl Extend<String> for String
    source§
    fn extend<I: IntoIterator<Item = String>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, s: String)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§
    impl Extend<char> for String
    source§
    fn extend<I: IntoIterator<Item = char>>(&mut self, iter: I)
    Extends a collection with the contents of an iterator. Read more
    source§
    fn extend_one(&mut self, c: char)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Extends a collection with exactly one element.
    source§
    fn extend_reserve(&mut self, additional: usize)
    🔬This is a nightly-only experimental API. (extend_one #72631)
    Reserves capacity in a collection for the given number of additional elements. Read more
    1.28.0 · source§
    impl<'a> From<&'a String> for Cow<'a, str>
    source§
    fn from(s: &'a String) -> Cow<'a, str>
    Converts a String reference into a Borrowed variant.
│ │ │ │  No heap allocation is performed, and the string
│ │ │ │  is not copied.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let s = "eggplant".to_string();
│ │ │ │  assert_eq!(Cow::from(&s), Cow::Borrowed("eggplant"));
    Run
    
│ │ │ │ -
    1.35.0 · source§
    impl From<&String> for String
    source§
    fn from(s: &String) -> String
    Converts a &String into a String.
    
│ │ │ │ +
    1.35.0 · source§
    impl From<&String> for String
    source§
    fn from(s: &String) -> String
    Converts a &String into a String.
    
│ │ │ │  
    This clones s and returns the clone.
    
│ │ │ │ -
    1.44.0 · source§
    impl From<&mut str> for String
    source§
    fn from(s: &mut str) -> String
    Converts a &mut str into a String.
    
│ │ │ │ +
    1.44.0 · source§
    impl From<&mut str> for String
    source§
    fn from(s: &mut str) -> String
    Converts a &mut str into a String.
    
│ │ │ │  
    The result is allocated on the heap.
    
│ │ │ │ -
    source§
    impl From<&str> for String
    source§
    fn from(s: &str) -> String
    Converts a &str into a String.
    
│ │ │ │ +
    source§
    impl From<&str> for String
    source§
    fn from(s: &str) -> String
    Converts a &str into a String.
    
│ │ │ │  
    The result is allocated on the heap.
    
│ │ │ │ -
    1.18.0 · source§
    impl From<Box<str>> for String
    source§
    fn from(s: Box<str>) -> String
    Converts the given boxed str slice to a String.
│ │ │ │ +
    1.18.0 · source§
    impl From<Box<str>> for String
    source§
    fn from(s: Box<str>) -> String
    Converts the given boxed str slice to a String.
│ │ │ │  It is notable that the str slice is owned.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s1: String = String::from("hello world");
│ │ │ │  let s2: Box<str> = s1.into_boxed_str();
│ │ │ │  let s3: String = String::from(s2);
│ │ │ │  
│ │ │ │  assert_eq!("hello world", s3)
    Run
    
│ │ │ │ -
    1.14.0 · source§
    impl<'a> From<Cow<'a, str>> for String
    source§
    fn from(s: Cow<'a, str>) -> String
    Converts a clone-on-write string to an owned
│ │ │ │ +
    1.14.0 · source§
    impl<'a> From<Cow<'a, str>> for String
    source§
    fn from(s: Cow<'a, str>) -> String
    Converts a clone-on-write string to an owned
│ │ │ │  instance of String.
    
│ │ │ │  
    This extracts the owned string,
│ │ │ │  clones the string if it is not already owned.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    // If the string is not owned...
│ │ │ │  let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
│ │ │ │  // It will allocate on the heap and copy the string.
│ │ │ │  let owned: String = String::from(cow);
│ │ │ │  assert_eq!(&owned[..], "eggplant");
    Run
    
│ │ │ │ -
    1.21.0 · source§
    impl From<String> for Arc<str>
    source§
    fn from(v: String) -> Arc<str>
    Allocate a reference-counted str and copy v into it.
    
│ │ │ │ +
    1.21.0 · source§
    impl From<String> for Arc<str>
    source§
    fn from(v: String) -> Arc<str>
    Allocate a reference-counted str and copy v into it.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let unique: String = "eggplant".to_owned();
│ │ │ │  let shared: Arc<str> = Arc::from(unique);
│ │ │ │  assert_eq!("eggplant", &shared[..]);
    Run
    
│ │ │ │ -
    1.6.0 · source§
    impl<'a> From<String> for Box<dyn Error + 'a>
    source§
    fn from(str_err: String) -> Box<dyn Error + 'a>
    Converts a String into a box of dyn Error.
    
│ │ │ │ +
    1.6.0 · source§
    impl<'a> From<String> for Box<dyn Error + 'a>
    source§
    fn from(str_err: String) -> Box<dyn Error + 'a>
    Converts a String into a box of dyn Error.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::error::Error;
│ │ │ │  use std::mem;
│ │ │ │  
│ │ │ │  let a_string_error = "a string error".to_string();
│ │ │ │  let a_boxed_error = Box::<dyn Error>::from(a_string_error);
│ │ │ │  assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
    Run
    
│ │ │ │ -
    source§
    impl<'a> From<String> for Box<dyn Error + Send + Sync + 'a>
    source§
    fn from(err: String) -> Box<dyn Error + Send + Sync + 'a>
    Converts a String into a box of dyn Error + Send + Sync.
    
│ │ │ │ +
    source§
    impl<'a> From<String> for Box<dyn Error + Send + Sync + 'a>
    source§
    fn from(err: String) -> Box<dyn Error + Send + Sync + 'a>
    Converts a String into a box of dyn Error + Send + Sync.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::error::Error;
│ │ │ │  use std::mem;
│ │ │ │  
│ │ │ │  let a_string_error = "a string error".to_string();
│ │ │ │  let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
│ │ │ │  assert!(
│ │ │ │      mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
    Run
    
│ │ │ │ -
    1.20.0 · source§
    impl From<String> for Box<str>
    source§
    fn from(s: String) -> Box<str>
    Converts the given String to a boxed str slice that is owned.
    
│ │ │ │ +
    1.20.0 · source§
    impl From<String> for Box<str>
    source§
    fn from(s: String) -> Box<str>
    Converts the given String to a boxed str slice that is owned.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s1: String = String::from("hello world");
│ │ │ │  let s2: Box<str> = Box::from(s1);
│ │ │ │  let s3: String = String::from(s2);
│ │ │ │  
│ │ │ │  assert_eq!("hello world", s3)
    Run
    
│ │ │ │ -
    source§
    impl<'a> From<String> for Cow<'a, str>
    source§
    fn from(s: String) -> Cow<'a, str>
    Converts a String into an Owned variant.
│ │ │ │ +
    source§
    impl<'a> From<String> for Cow<'a, str>
    source§
    fn from(s: String) -> Cow<'a, str>
    Converts a String into an Owned variant.
│ │ │ │  No heap allocation is performed, and the string
│ │ │ │  is not copied.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let s = "eggplant".to_string();
│ │ │ │  let s2 = "eggplant".to_string();
│ │ │ │  assert_eq!(Cow::from(s), Cow::<'static, str>::Owned(s2));
    Run
    
│ │ │ │ -
    1.21.0 · source§
    impl From<String> for Rc<str>
    source§
    fn from(v: String) -> Rc<str>
    Allocate a reference-counted string slice and copy v into it.
    
│ │ │ │ +
    1.21.0 · source§
    impl From<String> for Rc<str>
    source§
    fn from(v: String) -> Rc<str>
    Allocate a reference-counted string slice and copy v into it.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let original: String = "statue".to_owned();
│ │ │ │  let shared: Rc<str> = Rc::from(original);
│ │ │ │  assert_eq!("statue", &shared[..]);
    Run
    
│ │ │ │ -
    1.14.0 · source§
    impl From<String> for Vec<u8>
    source§
    fn from(string: String) -> Vec<u8>
    Converts the given String to a vector Vec that holds values of type u8.
    
│ │ │ │ +
    1.14.0 · source§
    impl From<String> for Vec<u8>
    source§
    fn from(string: String) -> Vec<u8>
    Converts the given String to a vector Vec that holds values of type u8.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let s1 = String::from("hello world");
│ │ │ │  let v1 = Vec::from(s1);
│ │ │ │  
│ │ │ │  for b in v1 {
│ │ │ │      println!("{b}");
│ │ │ │  }
    Run
    
│ │ │ │ -
    1.46.0 · source§
    impl From<char> for String
    source§
    fn from(c: char) -> Self
    Allocates an owned String from a single character.
    
│ │ │ │ +
    1.46.0 · source§
    impl From<char> for String
    source§
    fn from(c: char) -> Self
    Allocates an owned String from a single character.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let c: char = 'a';
│ │ │ │  let s: String = String::from(c);
│ │ │ │  assert_eq!("a", &s[..]);
    Run
    
│ │ │ │ -
    1.17.0 · source§
    impl<'a> FromIterator<&'a char> for String
    source§
    fn from_iter<I: IntoIterator<Item = &'a char>>(iter: I) -> String
    Creates a value from an iterator. Read more
    source§
    impl<'a> FromIterator<&'a str> for String
    source§
    fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> String
    Creates a value from an iterator. Read more
    1.45.0 · source§
    impl FromIterator<Box<str>> for String
    source§
    fn from_iter<I: IntoIterator<Item = Box<str>>>(iter: I) -> String
    Creates a value from an iterator. Read more
    1.19.0 · source§
    impl<'a> FromIterator<Cow<'a, str>> for String
    source§
    fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String
    Creates a value from an iterator. Read more
    1.12.0 · source§
    impl<'a> FromIterator<String> for Cow<'a, str>
    source§
    fn from_iter<I: IntoIterator<Item = String>>(it: I) -> Cow<'a, str>
    Creates a value from an iterator. Read more
    1.4.0 · source§
    impl FromIterator<String> for String
    source§
    fn from_iter<I: IntoIterator<Item = String>>(iter: I) -> String
    Creates a value from an iterator. Read more
    source§
    impl FromIterator<char> for String
    source§
    fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> String
    Creates a value from an iterator. Read more
    source§
    impl FromStr for String
    §
    type Err = Infallible
    The associated error which can be returned from parsing.
    source§
    fn from_str(s: &str) -> Result<String, Self::Err>
    Parses a string s to return a value of this type. Read more
    source§
    impl Hash for String
    source§
    fn hash<H: Hasher>(&self, hasher: &mut H)
    Feeds this value into the given Hasher. Read more
    1.3.0 · source§
    fn hash_slice<H>(data: &[Self], state: &mut H)
    where
│ │ │ │ -    H: Hasher,
│ │ │ │ -    Self: Sized,
    Feeds a slice of this type into the given Hasher. Read more
    source§
    impl<I> Index<I> for String
    where
│ │ │ │ -    I: SliceIndex<str>,
    §
    type Output = <I as SliceIndex<str>>::Output
    The returned type after indexing.
    source§
    fn index(&self, index: I) -> &I::Output
    Performs the indexing (container[index]) operation. Read more
    source§
    impl<I> IndexMut<I> for String
    where
│ │ │ │ -    I: SliceIndex<str>,
    source§
    fn index_mut(&mut self, index: I) -> &mut I::Output
    Performs the mutable indexing (container[index]) operation. Read more
    source§
    impl Ord for String
    source§
    fn cmp(&self, other: &String) -> Ordering
    This method returns an Ordering between self and other. Read more
    1.21.0 · source§
    fn max(self, other: Self) -> Self
    where
│ │ │ │ -    Self: Sized,
    Compares and returns the maximum of two values. Read more
    1.21.0 · source§
    fn min(self, other: Self) -> Self
    where
│ │ │ │ -    Self: Sized,
    Compares and returns the minimum of two values. Read more
    1.50.0 · source§
    fn clamp(self, min: Self, max: Self) -> Self
    where
│ │ │ │ -    Self: Sized + PartialOrd,
    Restrict a value to a certain interval. Read more
    source§
    impl<'a, 'b> PartialEq<&'a str> for String
    source§
    fn eq(&self, other: &&'a str) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    source§
    fn ne(&self, other: &&'a str) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl<'a, 'b> PartialEq<Cow<'a, str>> for String
    source§
    fn eq(&self, other: &Cow<'a, str>) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    source§
    fn ne(&self, other: &Cow<'a, str>) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl<'a, 'b> PartialEq<String> for &'a str
    source§
    fn eq(&self, other: &String) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    source§
    fn ne(&self, other: &String) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl<'a, 'b> PartialEq<String> for Cow<'a, str>
    source§
    fn eq(&self, other: &String) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    source§
    fn ne(&self, other: &String) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl<'a, 'b> PartialEq<String> for str
    source§
    fn eq(&self, other: &String) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    source§
    fn ne(&self, other: &String) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl<'a, 'b> PartialEq<str> for String
    source§
    fn eq(&self, other: &str) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    source§
    fn ne(&self, other: &str) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl PartialEq for String
    source§
    fn eq(&self, other: &String) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
    source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
    source§
    impl PartialOrd for String
    source§
    fn partial_cmp(&self, other: &String) -> Option<Ordering>
    This method returns an ordering between self and other values if one exists. Read more
    source§
    fn lt(&self, other: &Rhs) -> bool
    This method tests less than (for self and other) and is used by the < operator. Read more
    source§
    fn le(&self, other: &Rhs) -> bool
    This method tests less than or equal to (for self and other) and is used by the <=
│ │ │ │ -operator. Read more
    source§
    fn gt(&self, other: &Rhs) -> bool
    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§
    fn ge(&self, other: &Rhs) -> bool
    This method tests greater than or equal to (for self and other) and is used by the >=
│ │ │ │ -operator. Read more
    source§
    impl<'a, 'b> Pattern<'a> for &'b String
    A convenience impl that delegates to the impl for &str.
    
│ │ │ │ +
    1.17.0 · source§
    impl<'a> FromIterator<&'a char> for String
    source§
    fn from_iter<I: IntoIterator<Item = &'a char>>(iter: I) -> String
    Creates a value from an iterator. Read more
    source§
    impl<'a> FromIterator<&'a str> for String
    source§
    fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> String
    Creates a value from an iterator. Read more
    1.45.0 · source§
    impl FromIterator<Box<str>> for String
    source§
    fn from_iter<I: IntoIterator<Item = Box<str>>>(iter: I) -> String
    Creates a value from an iterator. Read more
    1.19.0 · source§
    impl<'a> FromIterator<Cow<'a, str>> for String
    source§
    fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String
    Creates a value from an iterator. Read more
    1.12.0 · source§
    impl<'a> FromIterator<String> for Cow<'a, str>
    source§
    fn from_iter<I: IntoIterator<Item = String>>(it: I) -> Cow<'a, str>
    Creates a value from an iterator. Read more
    1.4.0 · source§
    impl FromIterator<String> for String
    source§
    fn from_iter<I: IntoIterator<Item = String>>(iter: I) -> String
    Creates a value from an iterator. Read more
    source§
    impl FromIterator<char> for String
    source§
    fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> String
    Creates a value from an iterator. Read more
    source§
    impl FromStr for String
    §
    type Err = Infallible
    The associated error which can be returned from parsing.
    source§
    fn from_str(s: &str) -> Result<String, Self::Err>
    Parses a string s to return a value of this type. Read more
    source§
    impl Hash for String
    source§
    fn hash<H: Hasher>(&self, hasher: &mut H)
    Feeds this value into the given Hasher. Read more
    1.3.0 · source§
    fn hash_slice<H>(data: &[Self], state: &mut H)
    where
│ │ │ │ +    H: Hasher,
│ │ │ │ +    Self: Sized,
    Feeds a slice of this type into the given Hasher. Read more
    source§
    impl<I> Index<I> for String
    where
│ │ │ │ +    I: SliceIndex<str>,
    §
    type Output = <I as SliceIndex<str>>::Output
    The returned type after indexing.
    source§
    fn index(&self, index: I) -> &I::Output
    Performs the indexing (container[index]) operation. Read more
    source§
    impl<I> IndexMut<I> for String
    where
│ │ │ │ +    I: SliceIndex<str>,
    source§
    fn index_mut(&mut self, index: I) -> &mut I::Output
    Performs the mutable indexing (container[index]) operation. Read more
    source§
    impl Ord for String
    source§
    fn cmp(&self, other: &String) -> Ordering
    This method returns an Ordering between self and other. Read more
    1.21.0 · source§
    fn max(self, other: Self) -> Self
    where
│ │ │ │ +    Self: Sized,
    Compares and returns the maximum of two values. Read more
    1.21.0 · source§
    fn min(self, other: Self) -> Self
    where
│ │ │ │ +    Self: Sized,
    Compares and returns the minimum of two values. Read more
    1.50.0 · source§
    fn clamp(self, min: Self, max: Self) -> Self
    where
│ │ │ │ +    Self: Sized + PartialOrd,
    Restrict a value to a certain interval. Read more
    source§
    impl<'a, 'b> PartialEq<&'a str> for String
    source§
    fn eq(&self, other: &&'a str) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    source§
    fn ne(&self, other: &&'a str) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl<'a, 'b> PartialEq<Cow<'a, str>> for String
    source§
    fn eq(&self, other: &Cow<'a, str>) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    source§
    fn ne(&self, other: &Cow<'a, str>) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl<'a, 'b> PartialEq<String> for &'a str
    source§
    fn eq(&self, other: &String) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    source§
    fn ne(&self, other: &String) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl<'a, 'b> PartialEq<String> for Cow<'a, str>
    source§
    fn eq(&self, other: &String) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    source§
    fn ne(&self, other: &String) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl<'a, 'b> PartialEq<String> for str
    source§
    fn eq(&self, other: &String) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    source§
    fn ne(&self, other: &String) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl<'a, 'b> PartialEq<str> for String
    source§
    fn eq(&self, other: &str) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    source§
    fn ne(&self, other: &str) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl PartialEq for String
    source§
    fn eq(&self, other: &String) -> bool
    This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
    source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
    source§
    impl PartialOrd for String
    source§
    fn partial_cmp(&self, other: &String) -> Option<Ordering>
    This method returns an ordering between self and other values if one exists. Read more
    source§
    fn lt(&self, other: &Rhs) -> bool
    This method tests less than (for self and other) and is used by the < operator. Read more
    source§
    fn le(&self, other: &Rhs) -> bool
    This method tests less than or equal to (for self and other) and is used by the <=
│ │ │ │ +operator. Read more
    source§
    fn gt(&self, other: &Rhs) -> bool
    This method tests greater than (for self and other) and is used by the > operator. Read more
    source§
    fn ge(&self, other: &Rhs) -> bool
    This method tests greater than or equal to (for self and other) and is used by the >=
│ │ │ │ +operator. Read more
    source§
    impl<'a, 'b> Pattern<'a> for &'b String
    A convenience impl that delegates to the impl for &str.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    assert_eq!(String::from("Hello world").find("world"), Some(6));
    Run
    
│ │ │ │ -
    §
    type Searcher = <&'b str as Pattern<'a>>::Searcher
    🔬This is a nightly-only experimental API. (pattern #27721)
    Associated searcher for this pattern
    source§
    fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher
    🔬This is a nightly-only experimental API. (pattern #27721)
    Constructs the associated searcher from
│ │ │ │ -self and the haystack to search in.
    source§
    fn is_contained_in(self, haystack: &'a str) -> bool
    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches anywhere in the haystack
    source§
    fn is_prefix_of(self, haystack: &'a str) -> bool
    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches at the front of the haystack
    source§
    fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Removes the pattern from the front of haystack, if it matches.
    source§
    fn is_suffix_of(self, haystack: &'a str) -> bool
    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches at the back of the haystack
    source§
    fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Removes the pattern from the back of haystack, if it matches.
    source§
    impl Write for String
    source§
    fn write_str(&mut self, s: &str) -> Result
    Writes a string slice into this writer, returning whether the write
│ │ │ │ -succeeded. Read more
    source§
    fn write_char(&mut self, c: char) -> Result
    Writes a char into this writer, returning whether the write succeeded. Read more
    source§
    fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>
    Glue for usage of the write! macro with implementors of this trait. Read more
    source§
    impl Eq for String
    source§
    impl StructuralPartialEq for String
    Auto Trait Implementations§
    §
    impl Freeze for String
    §
    impl RefUnwindSafe for String
    §
    impl Send for String
    §
    impl Sync for String
    §
    impl Unpin for String
    §
    impl UnwindSafe for String
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    §
    type Searcher = <&'b str as Pattern<'a>>::Searcher
    🔬This is a nightly-only experimental API. (pattern #27721)
    Associated searcher for this pattern
    source§
    fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher
    🔬This is a nightly-only experimental API. (pattern #27721)
    Constructs the associated searcher from
│ │ │ │ +self and the haystack to search in.
    source§
    fn is_contained_in(self, haystack: &'a str) -> bool
    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches anywhere in the haystack
    source§
    fn is_prefix_of(self, haystack: &'a str) -> bool
    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches at the front of the haystack
    source§
    fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Removes the pattern from the front of haystack, if it matches.
    source§
    fn is_suffix_of(self, haystack: &'a str) -> bool
    🔬This is a nightly-only experimental API. (pattern #27721)
    Checks whether the pattern matches at the back of the haystack
    source§
    fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
    🔬This is a nightly-only experimental API. (pattern #27721)
    Removes the pattern from the back of haystack, if it matches.
    source§
    impl Write for String
    source§
    fn write_str(&mut self, s: &str) -> Result
    Writes a string slice into this writer, returning whether the write
│ │ │ │ +succeeded. Read more
    source§
    fn write_char(&mut self, c: char) -> Result
    Writes a char into this writer, returning whether the write succeeded. Read more
    source§
    fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>
    Glue for usage of the write! macro with implementors of this trait. Read more
    source§
    impl Eq for String
    source§
    impl StructuralPartialEq for String
    Auto Trait Implementations§
    §
    impl Freeze for String
    §
    impl RefUnwindSafe for String
    §
    impl Send for String
    §
    impl Sync for String
    §
    impl Unpin for String
    §
    impl UnwindSafe for String
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │  
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ -    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ +    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/string/trait.ToString.html
│ │ │ │ @@ -9,13 +9,13 @@
│ │ │ │  implementation for free.
    
│ │ │ │  
    Required Methods§
    source
    fn to_string(&self) -> String
    Converts the given value to a String.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let i = 5;
│ │ │ │  let five = String::from("5");
│ │ │ │  
│ │ │ │  assert_eq!(five, i.to_string());
    Run
    
│ │ │ │ -
    Implementors§
    source§
    impl<T: Display + ?Sized> ToString for T
    §Panics
    
│ │ │ │ +
    Implementors§
    source§
    impl<T: Display + ?Sized> ToString for T
    §Panics
    
│ │ │ │  
    In this implementation, the to_string method panics
│ │ │ │  if the Display implementation returns an error.
│ │ │ │  This indicates an incorrect Display implementation
│ │ │ │  since fmt::Write for String never returns an error itself.
    
│ │ │ │  
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/string/type.ParseError.html
│ │ │ │ @@ -1,4 +1,4 @@
│ │ │ │  ParseError in alloc::string - Rust
    
│ │ │ │ -    
    Type Alias alloc::string::ParseError
    1.5.0 · source · 
    pub type ParseError = Infallible;
    Expand description
    A type alias for Infallible.
    
│ │ │ │ +    
    Type Alias alloc::string::ParseError
    1.5.0 · source · 
    pub type ParseError = Infallible;
    Expand description
    A type alias for Infallible.
    
│ │ │ │  
    This alias exists for backwards compatibility, and may be eventually deprecated.
    
│ │ │ │  
    Aliased Type§
    enum ParseError {}
    Variants§
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/sync/index.html
│ │ │ │ @@ -3,8 +3,8 @@
│ │ │ │  
    See the Arc<T> documentation for more details.
    
│ │ │ │  
    Note: This module is only available on platforms that support atomic
│ │ │ │  loads and stores of pointers. This may be detected at compile time using
│ │ │ │  #[cfg(target_has_atomic = "ptr")].
    
│ │ │ │  
    Structs§
    • Arc
      A thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically
│ │ │ │  Reference Counted’.
    • Weak
      Weak is a version of Arc that holds a non-owning reference to the
│ │ │ │  managed allocation. The allocation is accessed by calling upgrade on the Weak
│ │ │ │ -pointer, which returns an Option<Arc<T>>.
    
│ │ │ │ +pointer, which returns an Option<Arc<T>>.
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/sync/struct.Arc.html
│ │ │ │ @@ -1,50 +1,50 @@
│ │ │ │  Arc in alloc::sync - Rust
    
│ │ │ │ -    
    Struct alloc::sync::Arc
    1.0.0 · source · 
    pub struct Arc<T: ?Sized, A: Allocator = Global> { /* private fields */ }
    Expand description
    A thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically
│ │ │ │ +    
    Struct alloc::sync::Arc
    1.0.0 · source · 
    pub struct Arc<T: ?Sized, A: Allocator = Global> { /* private fields */ }
    Expand description
    A thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically
│ │ │ │  Reference Counted’.
    
│ │ │ │  
    The type Arc<T> provides shared ownership of a value of type T,
│ │ │ │ -allocated in the heap. Invoking clone on Arc produces
│ │ │ │ +allocated in the heap. Invoking clone on Arc produces
│ │ │ │  a new Arc instance, which points to the same allocation on the heap as the
│ │ │ │  source Arc, while increasing a reference count. When the last Arc
│ │ │ │  pointer to a given allocation is destroyed, the value stored in that allocation (often
│ │ │ │  referred to as “inner value”) is also dropped.
    
│ │ │ │  
    Shared references in Rust disallow mutation by default, and Arc is no
│ │ │ │  exception: you cannot generally obtain a mutable reference to something
│ │ │ │  inside an Arc. If you need to mutate through an Arc, use
│ │ │ │ -Mutex, RwLock, or one of the Atomic
│ │ │ │ +Mutex, RwLock, or one of the Atomic
│ │ │ │  types.
    
│ │ │ │  
    Note: This type is only available on platforms that support atomic
│ │ │ │  loads and stores of pointers, which includes all platforms that support
│ │ │ │  the std crate but not all those which only support alloc.
│ │ │ │  This may be detected at compile time using #[cfg(target_has_atomic = "ptr")].
    
│ │ │ │  
    §Thread Safety
    
│ │ │ │  
    Unlike Rc<T>, Arc<T> uses atomic operations for its reference
│ │ │ │  counting. This means that it is thread-safe. The disadvantage is that
│ │ │ │  atomic operations are more expensive than ordinary memory accesses. If you
│ │ │ │  are not sharing reference-counted allocations between threads, consider using
│ │ │ │  Rc<T> for lower overhead. Rc<T> is a safe default, because the
│ │ │ │  compiler will catch any attempt to send an Rc<T> between threads.
│ │ │ │  However, a library might choose Arc<T> in order to give library consumers
│ │ │ │  more flexibility.
    
│ │ │ │ -
    Arc<T> will implement Send and Sync as long as the T implements
│ │ │ │ -Send and Sync. Why can’t you put a non-thread-safe type T in an
│ │ │ │ +
    Arc<T> will implement Send and Sync as long as the T implements
│ │ │ │ +Send and Sync. Why can’t you put a non-thread-safe type T in an
│ │ │ │  Arc<T> to make it thread-safe? This may be a bit counter-intuitive at
│ │ │ │  first: after all, isn’t the point of Arc<T> thread safety? The key is
│ │ │ │  this: Arc<T> makes it thread safe to have multiple ownership of the same
│ │ │ │  data, but it  doesn’t add thread safety to its data. Consider
│ │ │ │ -Arc<RefCell<T>>. RefCell<T> isn’t Sync, and if Arc<T> was always
│ │ │ │ -Send, Arc<RefCell<T>> would be as well. But then we’d have a problem:
│ │ │ │ -RefCell<T> is not thread safe; it keeps track of the borrowing count using
│ │ │ │ +Arc<RefCell<T>>. RefCell<T> isn’t Sync, and if Arc<T> was always
│ │ │ │ +Send, Arc<RefCell<T>> would be as well. But then we’d have a problem:
│ │ │ │ +RefCell<T> is not thread safe; it keeps track of the borrowing count using
│ │ │ │  non-atomic operations.
    
│ │ │ │  
    In the end, this means that you may need to pair Arc<T> with some sort of
│ │ │ │  std::sync type, usually Mutex<T>.
    
│ │ │ │  
    §Breaking cycles with Weak
    
│ │ │ │  
    The downgrade method can be used to create a non-owning
│ │ │ │  Weak pointer. A Weak pointer can be upgraded
│ │ │ │ -to an Arc, but this will return None if the value stored in the allocation has
│ │ │ │ +to an Arc, but this will return None if the value stored in the allocation has
│ │ │ │  already been dropped. In other words, Weak pointers do not keep the value
│ │ │ │  inside the allocation alive; however, they do keep the allocation
│ │ │ │  (the backing store for the value) alive.
    
│ │ │ │  
    A cycle between Arc pointers will never be deallocated. For this reason,
│ │ │ │  Weak is used to break cycles. For example, a tree could have
│ │ │ │  strong Arc pointers from parent nodes to children, and Weak
│ │ │ │  pointers from children back to their parents.
    
│ │ │ │ @@ -55,15 +55,15 @@
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  let foo = Arc::new(vec![1.0, 2.0, 3.0]);
│ │ │ │  // The two syntaxes below are equivalent.
│ │ │ │  let a = foo.clone();
│ │ │ │  let b = Arc::clone(&foo);
│ │ │ │  // a, b, and foo are all Arcs that point to the same memory location
    Run
    
│ │ │ │  
    §Deref behavior
    
│ │ │ │ -
    Arc<T> automatically dereferences to T (via the Deref trait),
│ │ │ │ +
    Arc<T> automatically dereferences to T (via the Deref trait),
│ │ │ │  so you can call T’s methods on a value of type Arc<T>. To avoid name
│ │ │ │  clashes with T’s methods, the methods of Arc<T> itself are associated
│ │ │ │  functions, called using fully qualified syntax:
    
│ │ │ │  
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let my_arc = Arc::new(());
│ │ │ │ @@ -92,15 +92,15 @@
│ │ │ │  for _ in 0..10 {
│ │ │ │      let five = Arc::clone(&five);
│ │ │ │  
│ │ │ │      thread::spawn(move || {
│ │ │ │          println!("{five:?}");
│ │ │ │      });
│ │ │ │  }
    Run
    
│ │ │ │ -
    Sharing a mutable AtomicUsize:
    
│ │ │ │ +
    Sharing a mutable AtomicUsize:
    
│ │ │ │  
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  use std::sync::atomic::{AtomicUsize, Ordering};
│ │ │ │  use std::thread;
│ │ │ │  
│ │ │ │  let val = Arc::new(AtomicUsize::new(5));
│ │ │ │  
│ │ │ │ @@ -116,15 +116,15 @@
│ │ │ │  counting in general.
    
│ │ │ │  
    Implementations§
    source§
    impl<T> Arc<T>
    source
    pub fn new(data: T) -> Arc<T>
    Constructs a new Arc<T>.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
    Run
    
│ │ │ │  
    1.60.0 · source
    pub fn new_cyclic<F>(data_fn: F) -> Arc<T>
    where
│ │ │ │ -    F: FnOnce(&Weak<T>) -> T,
    Constructs a new Arc<T> while giving you a Weak<T> to the allocation,
│ │ │ │ +    F: FnOnce(&Weak<T>) -> T,
    Constructs a new Arc<T> while giving you a Weak<T> to the allocation,
│ │ │ │  to allow you to construct a T which holds a weak pointer to itself.
    
│ │ │ │  
    Generally, a structure circularly referencing itself, either directly or
│ │ │ │  indirectly, should not hold a strong reference to itself to prevent a memory leak.
│ │ │ │  Using this function, you get access to the weak pointer during the
│ │ │ │  initialization of T, before the Arc<T> is created, such that you can
│ │ │ │  clone and store it inside the T.
    
│ │ │ │  
    new_cyclic first allocates the managed allocation for the Arc<T>,
│ │ │ │ @@ -156,52 +156,52 @@
│ │ │ │      }
│ │ │ │  
│ │ │ │      /// Return a reference counted pointer to Self.
│ │ │ │      fn me(&self) -> Arc<Self> {
│ │ │ │          self.me.upgrade().unwrap()
│ │ │ │      }
│ │ │ │  }Run
    
│ │ │ │ -
    source
    pub fn new_uninit() -> Arc<MaybeUninit<T>>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new Arc with uninitialized contents.
    
│ │ │ │ +
    source
    pub fn new_uninit() -> Arc<MaybeUninit<T>>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new Arc with uninitialized contents.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  
│ │ │ │  let mut five = Arc::<u32>::new_uninit();
│ │ │ │  
│ │ │ │  // Deferred initialization:
│ │ │ │  Arc::get_mut(&mut five).unwrap().write(5);
│ │ │ │  
│ │ │ │  let five = unsafe { five.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5)
    Run
    
│ │ │ │ -
    source
    pub fn new_zeroed() -> Arc<MaybeUninit<T>>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new Arc with uninitialized contents, with the memory
│ │ │ │ +
    source
    pub fn new_zeroed() -> Arc<MaybeUninit<T>>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new Arc with uninitialized contents, with the memory
│ │ │ │  being filled with 0 bytes.
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │  of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  
│ │ │ │  let zero = Arc::<u32>::new_zeroed();
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*zero, 0)
    Run
    
│ │ │ │ -
    1.33.0 · source
    pub fn pin(data: T) -> Pin<Arc<T>>
    Constructs a new Pin<Arc<T>>. If T does not implement Unpin, then
│ │ │ │ +
    1.33.0 · source
    pub fn pin(data: T) -> Pin<Arc<T>>
    Constructs a new Pin<Arc<T>>. If T does not implement Unpin, then
│ │ │ │  data will be pinned in memory and unable to be moved.
    
│ │ │ │ -
    source
    pub fn try_pin(data: T) -> Result<Pin<Arc<T>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Pin<Arc<T>>, return an error if allocation fails.
    
│ │ │ │ -
    source
    pub fn try_new(data: T) -> Result<Arc<T>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc<T>, returning an error if allocation fails.
    
│ │ │ │ +
    source
    pub fn try_pin(data: T) -> Result<Pin<Arc<T>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Pin<Arc<T>>, return an error if allocation fails.
    
│ │ │ │ +
    source
    pub fn try_new(data: T) -> Result<Arc<T>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc<T>, returning an error if allocation fails.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api)]
│ │ │ │  use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::try_new(5)?;
    Run
    
│ │ │ │ -
    source
    pub fn try_new_uninit() -> Result<Arc<MaybeUninit<T>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents, returning an error
│ │ │ │ +
    source
    pub fn try_new_uninit() -> Result<Arc<MaybeUninit<T>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents, returning an error
│ │ │ │  if allocation fails.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit, allocator_api)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  
│ │ │ │ @@ -209,40 +209,40 @@
│ │ │ │  
│ │ │ │  // Deferred initialization:
│ │ │ │  Arc::get_mut(&mut five).unwrap().write(5);
│ │ │ │  
│ │ │ │  let five = unsafe { five.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5);
    Run
    
│ │ │ │ -
    source
    pub fn try_new_zeroed() -> Result<Arc<MaybeUninit<T>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents, with the memory
│ │ │ │ +
    source
    pub fn try_new_zeroed() -> Result<Arc<MaybeUninit<T>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents, with the memory
│ │ │ │  being filled with 0 bytes, returning an error if allocation fails.
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │  of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit, allocator_api)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  
│ │ │ │  let zero = Arc::<u32>::try_new_zeroed()?;
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*zero, 0);
    Run
    
│ │ │ │ -
    source§
    impl<T, A: Allocator> Arc<T, A>
    source
    pub fn allocator(this: &Self) -> &A
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Returns a reference to the underlying allocator.
    
│ │ │ │ +
    source§
    impl<T, A: Allocator> Arc<T, A>
    source
    pub fn allocator(this: &Self) -> &A
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Returns a reference to the underlying allocator.
    
│ │ │ │  
    Note: this is an associated function, which means that you have
│ │ │ │  to call it as Arc::allocator(&a) instead of a.allocator(). This
│ │ │ │  is so that there is no conflict with a method on the inner type.
    
│ │ │ │  
    source
    pub fn new_in(data: T, alloc: A) -> Arc<T, A>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc<T> in the provided allocator.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let five = Arc::new_in(5, System);
    Run
    
│ │ │ │ -
    source
    pub fn new_uninit_in(alloc: A) -> Arc<MaybeUninit<T>, A>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents in the provided allocator.
    
│ │ │ │ +
    source
    pub fn new_uninit_in(alloc: A) -> Arc<MaybeUninit<T>, A>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents in the provided allocator.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  use std::alloc::System;
│ │ │ │ @@ -253,42 +253,42 @@
│ │ │ │      // Deferred initialization:
│ │ │ │      Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);
│ │ │ │  
│ │ │ │      five.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5)
    Run
    
│ │ │ │ -
    source
    pub fn new_zeroed_in(alloc: A) -> Arc<MaybeUninit<T>, A>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents, with the memory
│ │ │ │ +
    source
    pub fn new_zeroed_in(alloc: A) -> Arc<MaybeUninit<T>, A>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents, with the memory
│ │ │ │  being filled with 0 bytes, in the provided allocator.
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │  of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let zero = Arc::<u32, _>::new_zeroed_in(System);
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*zero, 0)
    Run
    
│ │ │ │ -
    source
    pub fn pin_in(data: T, alloc: A) -> Pin<Arc<T, A>>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Pin<Arc<T, A>> in the provided allocator. If T does not implement Unpin,
│ │ │ │ +
    source
    pub fn pin_in(data: T, alloc: A) -> Pin<Arc<T, A>>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Pin<Arc<T, A>> in the provided allocator. If T does not implement Unpin,
│ │ │ │  then data will be pinned in memory and unable to be moved.
    
│ │ │ │ -
    source
    pub fn try_pin_in(data: T, alloc: A) -> Result<Pin<Arc<T, A>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Pin<Arc<T, A>> in the provided allocator, return an error if allocation
│ │ │ │ +
    source
    pub fn try_pin_in(data: T, alloc: A) -> Result<Pin<Arc<T, A>>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Pin<Arc<T, A>> in the provided allocator, return an error if allocation
│ │ │ │  fails.
    
│ │ │ │ -
    source
    pub fn try_new_in(data: T, alloc: A) -> Result<Arc<T, A>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc<T, A> in the provided allocator, returning an error if allocation fails.
    
│ │ │ │ +
    source
    pub fn try_new_in(data: T, alloc: A) -> Result<Arc<T, A>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc<T, A> in the provided allocator, returning an error if allocation fails.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let five = Arc::try_new_in(5, System)?;
    Run
    
│ │ │ │ -
    source
    pub fn try_new_uninit_in(alloc: A) -> Result<Arc<MaybeUninit<T>, A>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents, in the provided allocator, returning an
│ │ │ │ +
    source
    pub fn try_new_uninit_in(alloc: A) -> Result<Arc<MaybeUninit<T>, A>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents, in the provided allocator, returning an
│ │ │ │  error if allocation fails.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit, allocator_api)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  use std::alloc::System;
│ │ │ │ @@ -299,62 +299,62 @@
│ │ │ │      // Deferred initialization:
│ │ │ │      Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);
│ │ │ │  
│ │ │ │      five.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5);
    Run
    
│ │ │ │ -
    source
    pub fn try_new_zeroed_in(alloc: A) -> Result<Arc<MaybeUninit<T>, A>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents, with the memory
│ │ │ │ +
    source
    pub fn try_new_zeroed_in(alloc: A) -> Result<Arc<MaybeUninit<T>, A>, AllocError>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Arc with uninitialized contents, with the memory
│ │ │ │  being filled with 0 bytes, in the provided allocator, returning an error if allocation
│ │ │ │  fails.
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and incorrect usage
│ │ │ │  of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit, allocator_api)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let zero = Arc::<u32, _>::try_new_zeroed_in(System)?;
│ │ │ │  let zero = unsafe { zero.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*zero, 0);
    Run
    
│ │ │ │ -
    1.4.0 · source
    pub fn try_unwrap(this: Self) -> Result<T, Self>
    Returns the inner value, if the Arc has exactly one strong reference.
    
│ │ │ │ -
    Otherwise, an Err is returned with the same Arc that was
│ │ │ │ +
    1.4.0 · source
    pub fn try_unwrap(this: Self) -> Result<T, Self>
    Returns the inner value, if the Arc has exactly one strong reference.
    
│ │ │ │ +
    Otherwise, an Err is returned with the same Arc that was
│ │ │ │  passed in.
    
│ │ │ │  
    This will succeed even if there are outstanding weak references.
    
│ │ │ │  
    It is strongly recommended to use Arc::into_inner instead if you don’t
│ │ │ │ -want to keep the Arc in the Err case.
│ │ │ │ -Immediately dropping the Err payload, like in the expression
│ │ │ │ +want to keep the Arc in the Err case.
│ │ │ │ +Immediately dropping the Err payload, like in the expression
│ │ │ │  Arc::try_unwrap(this).ok(), can still cause the strong count to
│ │ │ │  drop to zero and the inner value of the Arc to be dropped:
│ │ │ │  For instance if two threads each execute this expression in parallel, then
│ │ │ │  there is a race condition. The threads could first both check whether they
│ │ │ │  have the last clone of their Arc via Arc::try_unwrap, and then
│ │ │ │ -both drop their Arc in the call to ok,
│ │ │ │ +both drop their Arc in the call to ok,
│ │ │ │  taking the strong count from two down to zero.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let x = Arc::new(3);
│ │ │ │  assert_eq!(Arc::try_unwrap(x), Ok(3));
│ │ │ │  
│ │ │ │  let x = Arc::new(4);
│ │ │ │  let _y = Arc::clone(&x);
│ │ │ │  assert_eq!(*Arc::try_unwrap(x).unwrap_err(), 4);
    Run
    
│ │ │ │ -
    1.70.0 · source
    pub fn into_inner(this: Self) -> Option<T>
    Returns the inner value, if the Arc has exactly one strong reference.
    
│ │ │ │ -
    Otherwise, None is returned and the Arc is dropped.
    
│ │ │ │ +
    1.70.0 · source
    pub fn into_inner(this: Self) -> Option<T>
    Returns the inner value, if the Arc has exactly one strong reference.
    
│ │ │ │ +
    Otherwise, None is returned and the Arc is dropped.
    
│ │ │ │  
    This will succeed even if there are outstanding weak references.
    
│ │ │ │  
    If Arc::into_inner is called on every clone of this Arc,
│ │ │ │  it is guaranteed that exactly one of the calls returns the inner value.
│ │ │ │  This means in particular that the inner value is not dropped.
    
│ │ │ │  
    Arc::try_unwrap is conceptually similar to Arc::into_inner, but it
│ │ │ │  is meant for different use-cases. If used as a direct replacement
│ │ │ │  for Arc::into_inner anyway, such as with the expression
│ │ │ │ -Arc::try_unwrap(this).ok(), then it does
│ │ │ │ +Arc::try_unwrap(this).ok(), then it does
│ │ │ │  not give the same guarantee as described in the previous paragraph.
│ │ │ │  For more information, see the examples below and read the documentation
│ │ │ │  of Arc::try_unwrap.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    Minimal example demonstrating the guarantee that Arc::into_inner gives.
    
│ │ │ │  
│ │ │ │  
    use std::sync::Arc;
│ │ │ │ @@ -416,15 +416,15 @@
│ │ │ │  let y = x.clone();
│ │ │ │  
│ │ │ │  // Drop the clones in parallel
│ │ │ │  let x_thread = std::thread::spawn(|| drop(x));
│ │ │ │  let y_thread = std::thread::spawn(|| drop(y));
│ │ │ │  x_thread.join().unwrap();
│ │ │ │  y_thread.join().unwrap();
    Run
    
│ │ │ │ -
    source§
    impl<T> Arc<[T]>
    source
    pub fn new_uninit_slice(len: usize) -> Arc<[MaybeUninit<T>]>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new atomically reference-counted slice with uninitialized contents.
    
│ │ │ │ +
    source§
    impl<T> Arc<[T]>
    source
    pub fn new_uninit_slice(len: usize) -> Arc<[MaybeUninit<T>]>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new atomically reference-counted slice with uninitialized contents.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  
│ │ │ │  let mut values = Arc::<[u32]>::new_uninit_slice(3);
│ │ │ │ @@ -434,28 +434,28 @@
│ │ │ │  data[0].write(1);
│ │ │ │  data[1].write(2);
│ │ │ │  data[2].write(3);
│ │ │ │  
│ │ │ │  let values = unsafe { values.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [1, 2, 3])
    Run
    
│ │ │ │ -
    source
    pub fn new_zeroed_slice(len: usize) -> Arc<[MaybeUninit<T>]>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new atomically reference-counted slice with uninitialized contents, with the memory being
│ │ │ │ +
    source
    pub fn new_zeroed_slice(len: usize) -> Arc<[MaybeUninit<T>]>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new atomically reference-counted slice with uninitialized contents, with the memory being
│ │ │ │  filled with 0 bytes.
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and
│ │ │ │  incorrect usage of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  
│ │ │ │  let values = Arc::<[u32]>::new_zeroed_slice(3);
│ │ │ │  let values = unsafe { values.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [0, 0, 0])
    Run
    
│ │ │ │ -
    source§
    impl<T, A: Allocator> Arc<[T], A>
    source
    pub fn new_uninit_slice_in(len: usize, alloc: A) -> Arc<[MaybeUninit<T>], A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new atomically reference-counted slice with uninitialized contents in the
│ │ │ │ +
    source§
    impl<T, A: Allocator> Arc<[T], A>
    source
    pub fn new_uninit_slice_in(len: usize, alloc: A) -> Arc<[MaybeUninit<T>], A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new atomically reference-counted slice with uninitialized contents in the
│ │ │ │  provided allocator.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │  #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │ @@ -469,32 +469,32 @@
│ │ │ │      Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);
│ │ │ │      Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);
│ │ │ │  
│ │ │ │      values.assume_init()
│ │ │ │  };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [1, 2, 3])
    Run
    
│ │ │ │ -
    source
    pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Arc<[MaybeUninit<T>], A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new atomically reference-counted slice with uninitialized contents, with the memory being
│ │ │ │ +
    source
    pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Arc<[MaybeUninit<T>], A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Constructs a new atomically reference-counted slice with uninitialized contents, with the memory being
│ │ │ │  filled with 0 bytes, in the provided allocator.
    
│ │ │ │ -
    See MaybeUninit::zeroed for examples of correct and
│ │ │ │ +
    See MaybeUninit::zeroed for examples of correct and
│ │ │ │  incorrect usage of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::sync::Arc;
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let values = Arc::<[u32], _>::new_zeroed_slice_in(3, System);
│ │ │ │  let values = unsafe { values.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [0, 0, 0])
    Run
    
│ │ │ │ -
    source§
    impl<T, A: Allocator> Arc<MaybeUninit<T>, A>
    source
    pub unsafe fn assume_init(self) -> Arc<T, A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Converts to Arc<T>.
    
│ │ │ │ +
    source§
    impl<T, A: Allocator> Arc<MaybeUninit<T>, A>
    source
    pub unsafe fn assume_init(self) -> Arc<T, A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Converts to Arc<T>.
    
│ │ │ │  
    §Safety
    
│ │ │ │ -
    As with MaybeUninit::assume_init,
│ │ │ │ +
    As with MaybeUninit::assume_init,
│ │ │ │  it is up to the caller to guarantee that the inner value
│ │ │ │  really is in an initialized state.
│ │ │ │  Calling this when the content is not yet fully initialized
│ │ │ │  causes immediate undefined behavior.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │ @@ -505,17 +505,17 @@
│ │ │ │  
│ │ │ │  // Deferred initialization:
│ │ │ │  Arc::get_mut(&mut five).unwrap().write(5);
│ │ │ │  
│ │ │ │  let five = unsafe { five.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*five, 5)
    Run
    
│ │ │ │ -
    source§
    impl<T, A: Allocator> Arc<[MaybeUninit<T>], A>
    source
    pub unsafe fn assume_init(self) -> Arc<[T], A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Converts to Arc<[T]>.
    
│ │ │ │ +
    source§
    impl<T, A: Allocator> Arc<[MaybeUninit<T>], A>
    source
    pub unsafe fn assume_init(self) -> Arc<[T], A>
    🔬This is a nightly-only experimental API. (new_uninit #63291)
    Converts to Arc<[T]>.
    
│ │ │ │  
    §Safety
    
│ │ │ │ -
    As with MaybeUninit::assume_init,
│ │ │ │ +
    As with MaybeUninit::assume_init,
│ │ │ │  it is up to the caller to guarantee that the inner value
│ │ │ │  really is in an initialized state.
│ │ │ │  Calling this when the content is not yet fully initialized
│ │ │ │  causes immediate undefined behavior.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(new_uninit)]
│ │ │ │  #![feature(get_mut_unchecked)]
│ │ │ │ @@ -529,28 +529,28 @@
│ │ │ │  data[0].write(1);
│ │ │ │  data[1].write(2);
│ │ │ │  data[2].write(3);
│ │ │ │  
│ │ │ │  let values = unsafe { values.assume_init() };
│ │ │ │  
│ │ │ │  assert_eq!(*values, [1, 2, 3])
    Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized> Arc<T>
    1.17.0 · source
    pub unsafe fn from_raw(ptr: *const T) -> Self
    Constructs an Arc<T> from a raw pointer.
    
│ │ │ │ +
    source§
    impl<T: ?Sized> Arc<T>
    1.17.0 · source
    pub unsafe fn from_raw(ptr: *const T) -> Self
    Constructs an Arc<T> from a raw pointer.
    
│ │ │ │  
    The raw pointer must have been previously returned by a call to
│ │ │ │  Arc<U>::into_raw with the following requirements:
    
│ │ │ │  
      
│ │ │ │  
    • If U is sized, it must have the same size and alignment as T. This
│ │ │ │  is trivially true if U is T.
      • 
│ │ │ │  
    • If U is unsized, its data pointer must have the same size and
│ │ │ │  alignment as T. This is trivially true if Arc<U> was constructed
│ │ │ │  through Arc<T> and then converted to Arc<U> through an unsized
│ │ │ │  coercion.
      • 
│ │ │ │  
    
│ │ │ │  
    Note that if U or U’s data pointer is not T but has the same size
│ │ │ │  and alignment, this is basically like transmuting references of
│ │ │ │ -different types. See mem::transmute for more information
│ │ │ │ +different types. See mem::transmute for more information
│ │ │ │  on what restrictions apply in this case.
    
│ │ │ │  
    The user of from_raw has to make sure a specific value of T is only
│ │ │ │  dropped once.
    
│ │ │ │  
    This function is unsafe because improper use may lead to memory unsafety,
│ │ │ │  even if the returned Arc<T> is never accessed.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │ @@ -574,15 +574,15 @@
│ │ │ │  let x: Arc<[u32]> = Arc::new([1, 2, 3]);
│ │ │ │  let x_ptr: *const [u32] = Arc::into_raw(x);
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      let x: Arc<[u32; 3]> = Arc::from_raw(x_ptr.cast::<[u32; 3]>());
│ │ │ │      assert_eq!(&*x, &[1, 2, 3]);
│ │ │ │  }
    Run
    
│ │ │ │ -
    1.51.0 · source
    pub unsafe fn increment_strong_count(ptr: *const T)
    Increments the strong reference count on the Arc<T> associated with the
│ │ │ │ +
    1.51.0 · source
    pub unsafe fn increment_strong_count(ptr: *const T)
    Increments the strong reference count on the Arc<T> associated with the
│ │ │ │  provided pointer by one.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    The pointer must have been obtained through Arc::into_raw, and the
│ │ │ │  associated Arc instance must be valid (i.e. the strong count must be at
│ │ │ │  least 1) for the duration of this method.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │ @@ -594,15 +594,15 @@
│ │ │ │      Arc::increment_strong_count(ptr);
│ │ │ │  
│ │ │ │      // This assertion is deterministic because we haven't shared
│ │ │ │      // the `Arc` between threads.
│ │ │ │      let five = Arc::from_raw(ptr);
│ │ │ │      assert_eq!(2, Arc::strong_count(&five));
│ │ │ │  }
    Run
    
│ │ │ │ -
    1.51.0 · source
    pub unsafe fn decrement_strong_count(ptr: *const T)
    Decrements the strong reference count on the Arc<T> associated with the
│ │ │ │ +
    1.51.0 · source
    pub unsafe fn decrement_strong_count(ptr: *const T)
    Decrements the strong reference count on the Arc<T> associated with the
│ │ │ │  provided pointer by one.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    The pointer must have been obtained through Arc::into_raw, and the
│ │ │ │  associated Arc instance must be valid (i.e. the strong count must be at
│ │ │ │  least 1) when invoking this method. This method can be used to release the final
│ │ │ │  Arc and backing storage, but should not be called after the final Arc has been
│ │ │ │  released.
    
│ │ │ │ @@ -618,47 +618,47 @@
│ │ │ │      // Those assertions are deterministic because we haven't shared
│ │ │ │      // the `Arc` between threads.
│ │ │ │      let five = Arc::from_raw(ptr);
│ │ │ │      assert_eq!(2, Arc::strong_count(&five));
│ │ │ │      Arc::decrement_strong_count(ptr);
│ │ │ │      assert_eq!(1, Arc::strong_count(&five));
│ │ │ │  }Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized, A: Allocator> Arc<T, A>
    1.17.0 · source
    pub fn into_raw(this: Self) -> *const T
    Consumes the Arc, returning the wrapped pointer.
    
│ │ │ │ +
    source§
    impl<T: ?Sized, A: Allocator> Arc<T, A>
    1.17.0 · source
    pub fn into_raw(this: Self) -> *const T
    Consumes the Arc, returning the wrapped pointer.
    
│ │ │ │  
    To avoid a memory leak the pointer must be converted back to an Arc using
│ │ │ │  Arc::from_raw.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let x = Arc::new("hello".to_owned());
│ │ │ │  let x_ptr = Arc::into_raw(x);
│ │ │ │  assert_eq!(unsafe { &*x_ptr }, "hello");
    Run
    
│ │ │ │ -
    1.45.0 · source
    pub fn as_ptr(this: &Self) -> *const T
    Provides a raw pointer to the data.
    
│ │ │ │ +
    1.45.0 · source
    pub fn as_ptr(this: &Self) -> *const T
    Provides a raw pointer to the data.
    
│ │ │ │  
    The counts are not affected in any way and the Arc is not consumed. The pointer is valid for
│ │ │ │  as long as there are strong counts in the Arc.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let x = Arc::new("hello".to_owned());
│ │ │ │  let y = Arc::clone(&x);
│ │ │ │  let x_ptr = Arc::as_ptr(&x);
│ │ │ │  assert_eq!(x_ptr, Arc::as_ptr(&y));
│ │ │ │  assert_eq!(unsafe { &*x_ptr }, "hello");
    Run
    
│ │ │ │ -
    source
    pub unsafe fn from_raw_in(ptr: *const T, alloc: A) -> Self
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs an Arc<T, A> from a raw pointer.
    
│ │ │ │ +
    source
    pub unsafe fn from_raw_in(ptr: *const T, alloc: A) -> Self
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs an Arc<T, A> from a raw pointer.
    
│ │ │ │  
    The raw pointer must have been previously returned by a call to Arc<U, A>::into_raw with the following requirements:
    
│ │ │ │  
      
│ │ │ │  
    • If U is sized, it must have the same size and alignment as T. This
│ │ │ │  is trivially true if U is T.
      • 
│ │ │ │  
    • If U is unsized, its data pointer must have the same size and
│ │ │ │  alignment as T. This is trivially true if Arc<U> was constructed
│ │ │ │  through Arc<T> and then converted to Arc<U> through an unsized
│ │ │ │  coercion.
      • 
│ │ │ │  
    
│ │ │ │  
    Note that if U or U’s data pointer is not T but has the same size
│ │ │ │  and alignment, this is basically like transmuting references of
│ │ │ │ -different types. See mem::transmute for more information
│ │ │ │ +different types. See mem::transmute for more information
│ │ │ │  on what restrictions apply in this case.
    
│ │ │ │  
    The raw pointer must point to a block of memory allocated by alloc
    
│ │ │ │  
    The user of from_raw has to make sure a specific value of T is only
│ │ │ │  dropped once.
    
│ │ │ │  
    This function is unsafe because improper use may lead to memory unsafety,
│ │ │ │  even if the returned Arc<T> is never accessed.
    
│ │ │ │  
    §Examples
    
│ │ │ │ @@ -689,52 +689,52 @@
│ │ │ │  let x: Arc<[u32], _> = Arc::new_in([1, 2, 3], System);
│ │ │ │  let x_ptr: *const [u32] = Arc::into_raw(x);
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      let x: Arc<[u32; 3], _> = Arc::from_raw_in(x_ptr.cast::<[u32; 3]>(), System);
│ │ │ │      assert_eq!(&*x, &[1, 2, 3]);
│ │ │ │  }Run
    
│ │ │ │ -
    1.4.0 · source
    pub fn downgrade(this: &Self) -> Weak<T, A>
    where
│ │ │ │ -    A: Clone,
    Creates a new Weak pointer to this allocation.
    
│ │ │ │ +
    1.4.0 · source
    pub fn downgrade(this: &Self) -> Weak<T, A>
    where
│ │ │ │ +    A: Clone,
    Creates a new Weak pointer to this allocation.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  
│ │ │ │  let weak_five = Arc::downgrade(&five);
    Run
    
│ │ │ │ -
    1.15.0 · source
    pub fn weak_count(this: &Self) -> usize
    Gets the number of Weak pointers to this allocation.
    
│ │ │ │ +
    1.15.0 · source
    pub fn weak_count(this: &Self) -> usize
    Gets the number of Weak pointers to this allocation.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    This method by itself is safe, but using it correctly requires extra care.
│ │ │ │  Another thread can change the weak count at any time,
│ │ │ │  including potentially between calling this method and acting on the result.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  let _weak_five = Arc::downgrade(&five);
│ │ │ │  
│ │ │ │  // This assertion is deterministic because we haven't shared
│ │ │ │  // the `Arc` or `Weak` between threads.
│ │ │ │  assert_eq!(1, Arc::weak_count(&five));
    Run
    
│ │ │ │ -
    1.15.0 · source
    pub fn strong_count(this: &Self) -> usize
    Gets the number of strong (Arc) pointers to this allocation.
    
│ │ │ │ +
    1.15.0 · source
    pub fn strong_count(this: &Self) -> usize
    Gets the number of strong (Arc) pointers to this allocation.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    This method by itself is safe, but using it correctly requires extra care.
│ │ │ │  Another thread can change the strong count at any time,
│ │ │ │  including potentially between calling this method and acting on the result.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  let _also_five = Arc::clone(&five);
│ │ │ │  
│ │ │ │  // This assertion is deterministic because we haven't shared
│ │ │ │  // the `Arc` between threads.
│ │ │ │  assert_eq!(2, Arc::strong_count(&five));
    Run
    
│ │ │ │ -
    source
    pub unsafe fn increment_strong_count_in(ptr: *const T, alloc: A)
    where
│ │ │ │ -    A: Clone,
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Increments the strong reference count on the Arc<T> associated with the
│ │ │ │ +
    source
    pub unsafe fn increment_strong_count_in(ptr: *const T, alloc: A)
    where
│ │ │ │ +    A: Clone,
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Increments the strong reference count on the Arc<T> associated with the
│ │ │ │  provided pointer by one.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    The pointer must have been obtained through Arc::into_raw, and the
│ │ │ │  associated Arc instance must be valid (i.e. the strong count must be at
│ │ │ │  least 1) for the duration of this method,, and ptr must point to a block of memory
│ │ │ │  allocated by alloc.
    
│ │ │ │  
    §Examples
    
│ │ │ │ @@ -750,15 +750,15 @@
│ │ │ │      Arc::increment_strong_count_in(ptr, System);
│ │ │ │  
│ │ │ │      // This assertion is deterministic because we haven't shared
│ │ │ │      // the `Arc` between threads.
│ │ │ │      let five = Arc::from_raw_in(ptr, System);
│ │ │ │      assert_eq!(2, Arc::strong_count(&five));
│ │ │ │  }Run
    
│ │ │ │ -
    source
    pub unsafe fn decrement_strong_count_in(ptr: *const T, alloc: A)
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Decrements the strong reference count on the Arc<T> associated with the
│ │ │ │ +
    source
    pub unsafe fn decrement_strong_count_in(ptr: *const T, alloc: A)
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Decrements the strong reference count on the Arc<T> associated with the
│ │ │ │  provided pointer by one.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    The pointer must have been obtained through Arc::into_raw,  the
│ │ │ │  associated Arc instance must be valid (i.e. the strong count must be at
│ │ │ │  least 1) when invoking this method, and ptr must point to a block of memory
│ │ │ │  allocated by alloc. This method can be used to release the final
│ │ │ │  Arc and backing storage, but should not be called after the final Arc has been
│ │ │ │ @@ -778,28 +778,28 @@
│ │ │ │      // Those assertions are deterministic because we haven't shared
│ │ │ │      // the `Arc` between threads.
│ │ │ │      let five = Arc::from_raw_in(ptr, System);
│ │ │ │      assert_eq!(2, Arc::strong_count(&five));
│ │ │ │      Arc::decrement_strong_count_in(ptr, System);
│ │ │ │      assert_eq!(1, Arc::strong_count(&five));
│ │ │ │  }Run
    
│ │ │ │ -
    1.17.0 · source
    pub fn ptr_eq(this: &Self, other: &Self) -> bool
    Returns true if the two Arcs point to the same allocation in a vein similar to
│ │ │ │ -ptr::eq. This function ignores the metadata of  dyn Trait pointers.
    
│ │ │ │ +
    1.17.0 · source
    pub fn ptr_eq(this: &Self, other: &Self) -> bool
    Returns true if the two Arcs point to the same allocation in a vein similar to
│ │ │ │ +ptr::eq. This function ignores the metadata of  dyn Trait pointers.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  let same_five = Arc::clone(&five);
│ │ │ │  let other_five = Arc::new(5);
│ │ │ │  
│ │ │ │  assert!(Arc::ptr_eq(&five, &same_five));
│ │ │ │  assert!(!Arc::ptr_eq(&five, &other_five));
    Run
    
│ │ │ │ -
    source§
    impl<T: Clone, A: Allocator + Clone> Arc<T, A>
    1.4.0 · source
    pub fn make_mut(this: &mut Self) -> &mut T
    Makes a mutable reference into the given Arc.
    
│ │ │ │ +
    source§
    impl<T: Clone, A: Allocator + Clone> Arc<T, A>
    1.4.0 · source
    pub fn make_mut(this: &mut Self) -> &mut T
    Makes a mutable reference into the given Arc.
    
│ │ │ │  
    If there are other Arc pointers to the same allocation, then make_mut will
│ │ │ │ -clone the inner value to a new allocation to ensure unique ownership.  This is also
│ │ │ │ +clone the inner value to a new allocation to ensure unique ownership.  This is also
│ │ │ │  referred to as clone-on-write.
    
│ │ │ │  
    However, if there are no other Arc pointers to this allocation, but some Weak
│ │ │ │  pointers, then the Weak pointers will be dissociated and the inner value will not
│ │ │ │  be cloned.
    
│ │ │ │  
    See also get_mut, which will fail rather than cloning the inner value
│ │ │ │  or dissociating Weak pointers.
    
│ │ │ │  
    §Examples
    
│ │ │ │ @@ -848,30 +848,30 @@
│ │ │ │  let inner = Arc::unwrap_or_clone(arc);
│ │ │ │  // Because there were 2 references, we had to clone the inner value.
│ │ │ │  assert!(!ptr::eq(ptr, inner.as_ptr()));
│ │ │ │  // `arc2` is the last reference, so when we unwrap it we get back
│ │ │ │  // the original `String`.
│ │ │ │  let inner = Arc::unwrap_or_clone(arc2);
│ │ │ │  assert!(ptr::eq(ptr, inner.as_ptr()));Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized, A: Allocator> Arc<T, A>
    1.4.0 · source
    pub fn get_mut(this: &mut Self) -> Option<&mut T>
    Returns a mutable reference into the given Arc, if there are
│ │ │ │ +
    source§
    impl<T: ?Sized, A: Allocator> Arc<T, A>
    1.4.0 · source
    pub fn get_mut(this: &mut Self) -> Option<&mut T>
    Returns a mutable reference into the given Arc, if there are
│ │ │ │  no other Arc or Weak pointers to the same allocation.
    
│ │ │ │ -
    Returns None otherwise, because it is not safe to
│ │ │ │ +
    Returns None otherwise, because it is not safe to
│ │ │ │  mutate a shared value.
    
│ │ │ │ -
    See also make_mut, which will clone
│ │ │ │ +
    See also make_mut, which will clone
│ │ │ │  the inner value when there are other Arc pointers.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let mut x = Arc::new(3);
│ │ │ │  *Arc::get_mut(&mut x).unwrap() = 4;
│ │ │ │  assert_eq!(*x, 4);
│ │ │ │  
│ │ │ │  let _y = Arc::clone(&x);
│ │ │ │  assert!(Arc::get_mut(&mut x).is_none());
    Run
    
│ │ │ │ -
    source
    pub unsafe fn get_mut_unchecked(this: &mut Self) -> &mut T
    🔬This is a nightly-only experimental API. (get_mut_unchecked #63292)
    Returns a mutable reference into the given Arc,
│ │ │ │ +
    source
    pub unsafe fn get_mut_unchecked(this: &mut Self) -> &mut T
    🔬This is a nightly-only experimental API. (get_mut_unchecked #63292)
    Returns a mutable reference into the given Arc,
│ │ │ │  without any check.
    
│ │ │ │  
    See also get_mut, which is safe and does appropriate checks.
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    If any other Arc or Weak pointers to the same allocation exist, then
│ │ │ │  they must not be dereferenced or have active borrows for the duration
│ │ │ │  of the returned borrow, and their inner type must be exactly the same as the
│ │ │ │  inner type of this Rc (including lifetimes). This is trivially the case if no
│ │ │ │ @@ -912,31 +912,31 @@
│ │ │ │      unsafe {
│ │ │ │          // this is Undefined Behavior, because x's inner type
│ │ │ │          // is &'long str, not &'short str
│ │ │ │          *Arc::get_mut_unchecked(&mut y) = &s;
│ │ │ │      }
│ │ │ │  }
│ │ │ │  println!("{}", &*x); // Use-after-freeRun
    
│ │ │ │ -
    source§
    impl<A: Allocator> Arc<dyn Any + Send + Sync, A>
    1.29.0 · source
    pub fn downcast<T>(self) -> Result<Arc<T, A>, Self>
    where
│ │ │ │ -    T: Any + Send + Sync,
    Attempt to downcast the Arc<dyn Any + Send + Sync> to a concrete type.
    
│ │ │ │ +
    source§
    impl<A: Allocator> Arc<dyn Any + Send + Sync, A>
    1.29.0 · source
    pub fn downcast<T>(self) -> Result<Arc<T, A>, Self>
    where
│ │ │ │ +    T: Any + Send + Sync,
    Attempt to downcast the Arc<dyn Any + Send + Sync> to a concrete type.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::any::Any;
│ │ │ │  use std::sync::Arc;
│ │ │ │  
│ │ │ │  fn print_if_string(value: Arc<dyn Any + Send + Sync>) {
│ │ │ │      if let Ok(string) = value.downcast::<String>() {
│ │ │ │          println!("String ({}): {}", string.len(), string);
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  let my_string = "Hello World".to_string();
│ │ │ │  print_if_string(Arc::new(my_string));
│ │ │ │  print_if_string(Arc::new(0i8));
    Run
    
│ │ │ │  
    source
    pub unsafe fn downcast_unchecked<T>(self) -> Arc<T, A>
    where
│ │ │ │ -    T: Any + Send + Sync,
    🔬This is a nightly-only experimental API. (downcast_unchecked #90850)
    Downcasts the Arc<dyn Any + Send + Sync> to a concrete type.
    
│ │ │ │ +    T: Any + Send + Sync,
    🔬This is a nightly-only experimental API. (downcast_unchecked #90850)
    Downcasts the Arc<dyn Any + Send + Sync> to a concrete type.
    
│ │ │ │  
    For a safe alternative see downcast.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(downcast_unchecked)]
│ │ │ │  
│ │ │ │  use std::any::Any;
│ │ │ │  use std::sync::Arc;
│ │ │ │  
│ │ │ │ @@ -944,30 +944,30 @@
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      assert_eq!(*x.downcast_unchecked::<usize>(), 1);
│ │ │ │  }
    Run
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    The contained value must be of type T. Calling this method
│ │ │ │  with the incorrect type is undefined behavior.
    
│ │ │ │ -
    Trait Implementations§
    1.5.0 · source§
    impl<T: ?Sized, A: Allocator> AsRef<T> for Arc<T, A>
    source§
    fn as_ref(&self) -> &T
    Converts this type into a shared reference of the (usually inferred) input type.
    source§
    impl<T: ?Sized, A: Allocator> Borrow<T> for Arc<T, A>
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T: ?Sized, A: Allocator + Clone> Clone for Arc<T, A>
    source§
    fn clone(&self) -> Arc<T, A>
    Makes a clone of the Arc pointer.
    
│ │ │ │ +
    Trait Implementations§
    1.5.0 · source§
    impl<T: ?Sized, A: Allocator> AsRef<T> for Arc<T, A>
    source§
    fn as_ref(&self) -> &T
    Converts this type into a shared reference of the (usually inferred) input type.
    source§
    impl<T: ?Sized, A: Allocator> Borrow<T> for Arc<T, A>
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T: ?Sized, A: Allocator + Clone> Clone for Arc<T, A>
    source§
    fn clone(&self) -> Arc<T, A>
    Makes a clone of the Arc pointer.
    
│ │ │ │  
    This creates another pointer to the same allocation, increasing the
│ │ │ │  strong reference count.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  
│ │ │ │  let _ = Arc::clone(&five);
    Run
    
│ │ │ │ -
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<T: ?Sized + Debug, A: Allocator> Debug for Arc<T, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<T: Default> Default for Arc<T>
    source§
    fn default() -> Arc<T>
    Creates a new Arc<T>, with the Default value for T.
    
│ │ │ │ +
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<T: ?Sized + Debug, A: Allocator> Debug for Arc<T, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<T: Default> Default for Arc<T>
    source§
    fn default() -> Arc<T>
    Creates a new Arc<T>, with the Default value for T.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let x: Arc<i32> = Default::default();
│ │ │ │  assert_eq!(*x, 0);
    Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized, A: Allocator> Deref for Arc<T, A>
    §
    type Target = T
    The resulting type after dereferencing.
    source§
    fn deref(&self) -> &T
    Dereferences the value.
    source§
    impl<T: ?Sized + Display, A: Allocator> Display for Arc<T, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<T: ?Sized, A: Allocator> Drop for Arc<T, A>
    source§
    fn drop(&mut self)
    Drops the Arc.
    
│ │ │ │ +
    source§
    impl<T: ?Sized, A: Allocator> Deref for Arc<T, A>
    §
    type Target = T
    The resulting type after dereferencing.
    source§
    fn deref(&self) -> &T
    Dereferences the value.
    source§
    impl<T: ?Sized + Display, A: Allocator> Display for Arc<T, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<T: ?Sized, A: Allocator> Drop for Arc<T, A>
    source§
    fn drop(&mut self)
    Drops the Arc.
    
│ │ │ │  
    This will decrement the strong reference count. If the strong reference
│ │ │ │  count reaches zero then the only other references (if any) are
│ │ │ │  Weak, so we drop the inner value.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  struct Foo;
│ │ │ │ @@ -979,75 +979,75 @@
│ │ │ │  }
│ │ │ │  
│ │ │ │  let foo  = Arc::new(Foo);
│ │ │ │  let foo2 = Arc::clone(&foo);
│ │ │ │  
│ │ │ │  drop(foo);    // Doesn't print anything
│ │ │ │  drop(foo2);   // Prints "dropped!"
    Run
    
│ │ │ │ -
    1.52.0 · source§
    impl<T: Error + ?Sized> Error for Arc<T>
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    source§
    fn provide<'a>(&'a self, req: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    1.21.0 · source§
    impl<T: Clone> From<&[T]> for Arc<[T]>
    source§
    fn from(v: &[T]) -> Arc<[T]>
    Allocate a reference-counted slice and fill it by cloning v’s items.
    
│ │ │ │ +
    1.52.0 · source§
    impl<T: Error + ?Sized> Error for Arc<T>
    source§
    fn description(&self) -> &str
    👎Deprecated since 1.42.0: use the Display impl or to_string()
     Read more
    source§
    fn cause(&self) -> Option<&dyn Error>
    👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
    source§
    fn source(&self) -> Option<&(dyn Error + 'static)>
    The lower-level source of this error, if any. Read more
    source§
    fn provide<'a>(&'a self, req: &mut Request<'a>)
    🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
    Provides type based access to context intended for error reports. Read more
    1.21.0 · source§
    impl<T: Clone> From<&[T]> for Arc<[T]>
    source§
    fn from(v: &[T]) -> Arc<[T]>
    Allocate a reference-counted slice and fill it by cloning v’s items.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let original: &[i32] = &[1, 2, 3];
│ │ │ │  let shared: Arc<[i32]> = Arc::from(original);
│ │ │ │  assert_eq!(&[1, 2, 3], &shared[..]);
    Run
    
│ │ │ │ -
    1.24.0 · source§
    impl From<&CStr> for Arc<CStr>
    source§
    fn from(s: &CStr) -> Arc<CStr>
    Converts a &CStr into a Arc<CStr>,
│ │ │ │ +
    1.24.0 · source§
    impl From<&CStr> for Arc<CStr>
    source§
    fn from(s: &CStr) -> Arc<CStr>
    Converts a &CStr into a Arc<CStr>,
│ │ │ │  by copying the contents into a newly allocated Arc.
    
│ │ │ │ -
    1.21.0 · source§
    impl From<&str> for Arc<str>
    source§
    fn from(v: &str) -> Arc<str>
    Allocate a reference-counted str and copy v into it.
    
│ │ │ │ +
    1.21.0 · source§
    impl From<&str> for Arc<str>
    source§
    fn from(v: &str) -> Arc<str>
    Allocate a reference-counted str and copy v into it.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let shared: Arc<str> = Arc::from("eggplant");
│ │ │ │  assert_eq!("eggplant", &shared[..]);
    Run
    
│ │ │ │ -
    1.74.0 · source§
    impl<T, const N: usize> From<[T; N]> for Arc<[T]>
    source§
    fn from(v: [T; N]) -> Arc<[T]>
    Converts a [T; N] into an Arc<[T]>.
    
│ │ │ │ +
    1.74.0 · source§
    impl<T, const N: usize> From<[T; N]> for Arc<[T]>
    source§
    fn from(v: [T; N]) -> Arc<[T]>
    Converts a [T; N] into an Arc<[T]>.
    
│ │ │ │  
    The conversion moves the array into a newly allocated Arc.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let original: [i32; 3] = [1, 2, 3];
│ │ │ │  let shared: Arc<[i32]> = Arc::from(original);
│ │ │ │  assert_eq!(&[1, 2, 3], &shared[..]);
    Run
    
│ │ │ │ -
    1.51.0 · source§
    impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for RawWaker
    source§
    fn from(waker: Arc<W>) -> RawWaker
    Use a Wake-able type as a RawWaker.
    
│ │ │ │ +
    1.51.0 · source§
    impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for RawWaker
    source§
    fn from(waker: Arc<W>) -> RawWaker
    Use a Wake-able type as a RawWaker.
    
│ │ │ │  
    No heap allocations or atomic operations are used for this conversion.
    
│ │ │ │ -
    1.51.0 · source§
    impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for Waker
    source§
    fn from(waker: Arc<W>) -> Waker
    Use a Wake-able type as a Waker.
    
│ │ │ │ +
    1.51.0 · source§
    impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for Waker
    source§
    fn from(waker: Arc<W>) -> Waker
    Use a Wake-able type as a Waker.
    
│ │ │ │  
    No heap allocations or atomic operations are used for this conversion.
    
│ │ │ │ -
    1.62.0 · source§
    impl From<Arc<str>> for Arc<[u8]>
    source§
    fn from(rc: Arc<str>) -> Self
    Converts an atomically reference-counted string slice into a byte slice.
    
│ │ │ │ +
    1.62.0 · source§
    impl From<Arc<str>> for Arc<[u8]>
    source§
    fn from(rc: Arc<str>) -> Self
    Converts an atomically reference-counted string slice into a byte slice.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let string: Arc<str> = Arc::from("eggplant");
│ │ │ │  let bytes: Arc<[u8]> = Arc::from(string);
│ │ │ │  assert_eq!("eggplant".as_bytes(), bytes.as_ref());
    Run
    
│ │ │ │ -
    1.21.0 · source§
    impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Arc<T, A>
    source§
    fn from(v: Box<T, A>) -> Arc<T, A>
    Move a boxed object to a new, reference-counted allocation.
    
│ │ │ │ +
    1.21.0 · source§
    impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Arc<T, A>
    source§
    fn from(v: Box<T, A>) -> Arc<T, A>
    Move a boxed object to a new, reference-counted allocation.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let unique: Box<str> = Box::from("eggplant");
│ │ │ │  let shared: Arc<str> = Arc::from(unique);
│ │ │ │  assert_eq!("eggplant", &shared[..]);
    Run
    
│ │ │ │ -
    1.24.0 · source§
    impl From<CString> for Arc<CStr>
    source§
    fn from(s: CString) -> Arc<CStr>
    Converts a CString into an Arc<CStr> by moving the CString
│ │ │ │ +
    1.24.0 · source§
    impl From<CString> for Arc<CStr>
    source§
    fn from(s: CString) -> Arc<CStr>
    Converts a CString into an Arc<CStr> by moving the CString
│ │ │ │  data into a new Arc buffer.
    
│ │ │ │ -
    1.45.0 · source§
    impl<'a, B> From<Cow<'a, B>> for Arc<B>
    where
│ │ │ │ -    B: ToOwned + ?Sized,
│ │ │ │ -    Arc<B>: From<&'a B> + From<B::Owned>,
    source§
    fn from(cow: Cow<'a, B>) -> Arc<B>
    Create an atomically reference-counted pointer from
│ │ │ │ +
    1.45.0 · source§
    impl<'a, B> From<Cow<'a, B>> for Arc<B>
    where
│ │ │ │ +    B: ToOwned + ?Sized,
│ │ │ │ +    Arc<B>: From<&'a B> + From<B::Owned>,
    source§
    fn from(cow: Cow<'a, B>) -> Arc<B>
    Create an atomically reference-counted pointer from
│ │ │ │  a clone-on-write pointer by copying its content.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
│ │ │ │  let shared: Arc<str> = Arc::from(cow);
│ │ │ │  assert_eq!("eggplant", &shared[..]);
    Run
    
│ │ │ │ -
    1.21.0 · source§
    impl From<String> for Arc<str>
    source§
    fn from(v: String) -> Arc<str>
    Allocate a reference-counted str and copy v into it.
    
│ │ │ │ +
    1.21.0 · source§
    impl From<String> for Arc<str>
    source§
    fn from(v: String) -> Arc<str>
    Allocate a reference-counted str and copy v into it.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let unique: String = "eggplant".to_owned();
│ │ │ │  let shared: Arc<str> = Arc::from(unique);
│ │ │ │  assert_eq!("eggplant", &shared[..]);
    Run
    
│ │ │ │ -
    1.6.0 · source§
    impl<T> From<T> for Arc<T>
    source§
    fn from(t: T) -> Self
    Converts a T into an Arc<T>
    
│ │ │ │ +
    1.6.0 · source§
    impl<T> From<T> for Arc<T>
    source§
    fn from(t: T) -> Self
    Converts a T into an Arc<T>
    
│ │ │ │  
    The conversion moves the value into a
│ │ │ │  newly allocated Arc. It is equivalent to
│ │ │ │  calling Arc::new(t).
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let x = 5;
│ │ │ │  let arc = Arc::new(5);
│ │ │ │  
│ │ │ │  assert_eq!(Arc::from(x), arc);
    Run
    
│ │ │ │ -
    1.21.0 · source§
    impl<T, A: Allocator + Clone> From<Vec<T, A>> for Arc<[T], A>
    source§
    fn from(v: Vec<T, A>) -> Arc<[T], A>
    Allocate a reference-counted slice and move v’s items into it.
    
│ │ │ │ +
    1.21.0 · source§
    impl<T, A: Allocator + Clone> From<Vec<T, A>> for Arc<[T], A>
    source§
    fn from(v: Vec<T, A>) -> Arc<[T], A>
    Allocate a reference-counted slice and move v’s items into it.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let unique: Vec<i32> = vec![1, 2, 3];
│ │ │ │  let shared: Arc<[i32]> = Arc::from(unique);
│ │ │ │  assert_eq!(&[1, 2, 3], &shared[..]);
    Run
    
│ │ │ │ -
    1.37.0 · source§
    impl<T> FromIterator<T> for Arc<[T]>
    source§
    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self
    Takes each element in the Iterator and collects it into an Arc<[T]>.
    
│ │ │ │ +
    1.37.0 · source§
    impl<T> FromIterator<T> for Arc<[T]>
    source§
    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self
    Takes each element in the Iterator and collects it into an Arc<[T]>.
    
│ │ │ │  
    §Performance characteristics
    §The general case
    
│ │ │ │  
    In the general case, collecting into Arc<[T]> is done by first
│ │ │ │  collecting into a Vec<T>. That is, when writing the following:
    
│ │ │ │  
│ │ │ │  
    let evens: Arc<[u8]> = (0..10).filter(|&x| x % 2 == 0).collect();
    Run
    
│ │ │ │  
    this behaves as if we wrote:
    
│ │ │ │  
│ │ │ │ @@ -1057,99 +1057,99 @@
│ │ │ │  
    This will allocate as many times as needed for constructing the Vec<T>
│ │ │ │  and then it will allocate once for turning the Vec<T> into the Arc<[T]>.
    
│ │ │ │  
    §Iterators of known length
    
│ │ │ │  
    When your Iterator implements TrustedLen and is of an exact size,
│ │ │ │  a single allocation will be made for the Arc<[T]>. For example:
    
│ │ │ │  
│ │ │ │  
    let evens: Arc<[u8]> = (0..10).collect(); // Just a single allocation happens here.
    Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized + Hash, A: Allocator> Hash for Arc<T, A>
    source§
    fn hash<H: Hasher>(&self, state: &mut H)
    Feeds this value into the given Hasher. Read more
    1.3.0 · source§
    fn hash_slice<H>(data: &[Self], state: &mut H)
    where
│ │ │ │ -    H: Hasher,
│ │ │ │ -    Self: Sized,
    Feeds a slice of this type into the given Hasher. Read more
    source§
    impl<T: ?Sized + Ord, A: Allocator> Ord for Arc<T, A>
    source§
    fn cmp(&self, other: &Arc<T, A>) -> Ordering
    Comparison for two Arcs.
    
│ │ │ │ +
    source§
    impl<T: ?Sized + Hash, A: Allocator> Hash for Arc<T, A>
    source§
    fn hash<H: Hasher>(&self, state: &mut H)
    Feeds this value into the given Hasher. Read more
    1.3.0 · source§
    fn hash_slice<H>(data: &[Self], state: &mut H)
    where
│ │ │ │ +    H: Hasher,
│ │ │ │ +    Self: Sized,
    Feeds a slice of this type into the given Hasher. Read more
    source§
    impl<T: ?Sized + Ord, A: Allocator> Ord for Arc<T, A>
    source§
    fn cmp(&self, other: &Arc<T, A>) -> Ordering
    Comparison for two Arcs.
    
│ │ │ │  
    The two are compared by calling cmp() on their inner values.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  use std::cmp::Ordering;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  
│ │ │ │  assert_eq!(Ordering::Less, five.cmp(&Arc::new(6)));
    Run
    
│ │ │ │ -
    1.21.0 · source§
    fn max(self, other: Self) -> Self
    where
│ │ │ │ -    Self: Sized,
    Compares and returns the maximum of two values. Read more
    1.21.0 · source§
    fn min(self, other: Self) -> Self
    where
│ │ │ │ -    Self: Sized,
    Compares and returns the minimum of two values. Read more
    1.50.0 · source§
    fn clamp(self, min: Self, max: Self) -> Self
    where
│ │ │ │ -    Self: Sized + PartialOrd,
    Restrict a value to a certain interval. Read more
    source§
    impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Arc<T, A>
    source§
    fn eq(&self, other: &Arc<T, A>) -> bool
    Equality for two Arcs.
    
│ │ │ │ +
    1.21.0 · source§
    fn max(self, other: Self) -> Self
    where
│ │ │ │ +    Self: Sized,
    Compares and returns the maximum of two values. Read more
    1.21.0 · source§
    fn min(self, other: Self) -> Self
    where
│ │ │ │ +    Self: Sized,
    Compares and returns the minimum of two values. Read more
    1.50.0 · source§
    fn clamp(self, min: Self, max: Self) -> Self
    where
│ │ │ │ +    Self: Sized + PartialOrd,
    Restrict a value to a certain interval. Read more
    source§
    impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Arc<T, A>
    source§
    fn eq(&self, other: &Arc<T, A>) -> bool
    Equality for two Arcs.
    
│ │ │ │  
    Two Arcs are equal if their inner values are equal, even if they are
│ │ │ │  stored in different allocation.
    
│ │ │ │  
    If T also implements Eq (implying reflexivity of equality),
│ │ │ │  two Arcs that point to the same allocation are always equal.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  
│ │ │ │  assert!(five == Arc::new(5));
    Run
    
│ │ │ │ -
    source§
    fn ne(&self, other: &Arc<T, A>) -> bool
    Inequality for two Arcs.
    
│ │ │ │ +
    source§
    fn ne(&self, other: &Arc<T, A>) -> bool
    Inequality for two Arcs.
    
│ │ │ │  
    Two Arcs are not equal if their inner values are not equal.
    
│ │ │ │  
    If T also implements Eq (implying reflexivity of equality),
│ │ │ │  two Arcs that point to the same value are always equal.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  
│ │ │ │  assert!(five != Arc::new(6));
    Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Arc<T, A>
    source§
    fn partial_cmp(&self, other: &Arc<T, A>) -> Option<Ordering>
    Partial comparison for two Arcs.
    
│ │ │ │ +
    source§
    impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Arc<T, A>
    source§
    fn partial_cmp(&self, other: &Arc<T, A>) -> Option<Ordering>
    Partial comparison for two Arcs.
    
│ │ │ │  
    The two are compared by calling partial_cmp() on their inner values.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  use std::cmp::Ordering;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  
│ │ │ │  assert_eq!(Some(Ordering::Less), five.partial_cmp(&Arc::new(6)));
    Run
    
│ │ │ │ -
    source§
    fn lt(&self, other: &Arc<T, A>) -> bool
    Less-than comparison for two Arcs.
    
│ │ │ │ +
    source§
    fn lt(&self, other: &Arc<T, A>) -> bool
    Less-than comparison for two Arcs.
    
│ │ │ │  
    The two are compared by calling < on their inner values.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  
│ │ │ │  assert!(five < Arc::new(6));
    Run
    
│ │ │ │ -
    source§
    fn le(&self, other: &Arc<T, A>) -> bool
    ‘Less than or equal to’ comparison for two Arcs.
    
│ │ │ │ +
    source§
    fn le(&self, other: &Arc<T, A>) -> bool
    ‘Less than or equal to’ comparison for two Arcs.
    
│ │ │ │  
    The two are compared by calling <= on their inner values.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  
│ │ │ │  assert!(five <= Arc::new(5));
    Run
    
│ │ │ │ -
    source§
    fn gt(&self, other: &Arc<T, A>) -> bool
    Greater-than comparison for two Arcs.
    
│ │ │ │ +
    source§
    fn gt(&self, other: &Arc<T, A>) -> bool
    Greater-than comparison for two Arcs.
    
│ │ │ │  
    The two are compared by calling > on their inner values.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  
│ │ │ │  assert!(five > Arc::new(4));
    Run
    
│ │ │ │ -
    source§
    fn ge(&self, other: &Arc<T, A>) -> bool
    ‘Greater than or equal to’ comparison for two Arcs.
    
│ │ │ │ +
    source§
    fn ge(&self, other: &Arc<T, A>) -> bool
    ‘Greater than or equal to’ comparison for two Arcs.
    
│ │ │ │  
    The two are compared by calling >= on their inner values.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  
│ │ │ │  assert!(five >= Arc::new(5));
    Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized, A: Allocator> Pointer for Arc<T, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter.
    1.43.0 · source§
    impl<T, A: Allocator, const N: usize> TryFrom<Arc<[T], A>> for Arc<[T; N], A>
    §
    type Error = Arc<[T], A>
    The type returned in the event of a conversion error.
    source§
    fn try_from(boxed_slice: Arc<[T], A>) -> Result<Self, Self::Error>
    Performs the conversion.
    source§
    impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Arc<U, A>> for Arc<T, A>
    source§
    impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Arc<U>> for Arc<T>
    source§
    impl<T: ?Sized + Eq, A: Allocator> Eq for Arc<T, A>
    source§
    impl<T: ?Sized + Sync + Send, A: Allocator + Send> Send for Arc<T, A>
    source§
    impl<T: ?Sized + Sync + Send, A: Allocator + Sync> Sync for Arc<T, A>
    1.33.0 · source§
    impl<T: ?Sized, A: Allocator> Unpin for Arc<T, A>
    1.9.0 · source§
    impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> UnwindSafe for Arc<T, A>
    Auto Trait Implementations§
    §
    impl<T: ?Sized, A> Freeze for Arc<T, A>
    where
│ │ │ │ -    A: Freeze,
    §
    impl<T: ?Sized, A> RefUnwindSafe for Arc<T, A>
    where
│ │ │ │ -    A: RefUnwindSafe,
│ │ │ │ -    T: RefUnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<!> for T
    source§
    fn from(t: !) -> T
    Converts to this type from the input type.
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    source§
    impl<T: ?Sized, A: Allocator> Pointer for Arc<T, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter.
    1.43.0 · source§
    impl<T, A: Allocator, const N: usize> TryFrom<Arc<[T], A>> for Arc<[T; N], A>
    §
    type Error = Arc<[T], A>
    The type returned in the event of a conversion error.
    source§
    fn try_from(boxed_slice: Arc<[T], A>) -> Result<Self, Self::Error>
    Performs the conversion.
    source§
    impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Arc<U, A>> for Arc<T, A>
    source§
    impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Arc<U>> for Arc<T>
    source§
    impl<T: ?Sized + Eq, A: Allocator> Eq for Arc<T, A>
    source§
    impl<T: ?Sized + Sync + Send, A: Allocator + Send> Send for Arc<T, A>
    source§
    impl<T: ?Sized + Sync + Send, A: Allocator + Sync> Sync for Arc<T, A>
    1.33.0 · source§
    impl<T: ?Sized, A: Allocator> Unpin for Arc<T, A>
    1.9.0 · source§
    impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> UnwindSafe for Arc<T, A>
    Auto Trait Implementations§
    §
    impl<T: ?Sized, A> Freeze for Arc<T, A>
    where
│ │ │ │ +    A: Freeze,
    §
    impl<T: ?Sized, A> RefUnwindSafe for Arc<T, A>
    where
│ │ │ │ +    A: RefUnwindSafe,
│ │ │ │ +    T: RefUnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<!> for T
    source§
    fn from(t: !) -> T
    Converts to this type from the input type.
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │  
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ -    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T> ToString for T
    where
│ │ │ │ +    T: Display + ?Sized,
    source§
    default fn to_string(&self) -> String
    Converts the given value to a String. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/sync/struct.Weak.html
│ │ │ │ @@ -1,42 +1,42 @@
│ │ │ │  Weak in alloc::sync - Rust
    
│ │ │ │ -    
    Struct alloc::sync::Weak
    1.4.0 · source · 
    pub struct Weak<T: ?Sized, A: Allocator = Global> { /* private fields */ }
    Expand description
    Weak is a version of Arc that holds a non-owning reference to the
│ │ │ │ +    
    Struct alloc::sync::Weak
    1.4.0 · source · 
    pub struct Weak<T: ?Sized, A: Allocator = Global> { /* private fields */ }
    Expand description
    Weak is a version of Arc that holds a non-owning reference to the
│ │ │ │  managed allocation. The allocation is accessed by calling upgrade on the Weak
│ │ │ │ -pointer, which returns an Option<Arc<T>>.
    
│ │ │ │ +pointer, which returns an Option<Arc<T>>.
    
│ │ │ │  
    Since a Weak reference does not count towards ownership, it will not
│ │ │ │  prevent the value stored in the allocation from being dropped, and Weak itself makes no
│ │ │ │ -guarantees about the value still being present. Thus it may return None
│ │ │ │ +guarantees about the value still being present. Thus it may return None
│ │ │ │  when upgraded. Note however that a Weak reference does prevent the allocation
│ │ │ │  itself (the backing store) from being deallocated.
    
│ │ │ │  
    A Weak pointer is useful for keeping a temporary reference to the allocation
│ │ │ │  managed by Arc without preventing its inner value from being dropped. It is also used to
│ │ │ │  prevent circular references between Arc pointers, since mutual owning references
│ │ │ │  would never allow either Arc to be dropped. For example, a tree could
│ │ │ │  have strong Arc pointers from parent nodes to children, and Weak
│ │ │ │  pointers from children back to their parents.
    
│ │ │ │  
    The typical way to obtain a Weak pointer is to call Arc::downgrade.
    
│ │ │ │  
    Implementations§
    source§
    impl<T> Weak<T>
    1.10.0 (const: 1.73.0) · source
    pub const fn new() -> Weak<T>
    Constructs a new Weak<T>, without allocating any memory.
│ │ │ │ -Calling upgrade on the return value always gives None.
    
│ │ │ │ +Calling upgrade on the return value always gives None.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Weak;
│ │ │ │  
│ │ │ │  let empty: Weak<i64> = Weak::new();
│ │ │ │  assert!(empty.upgrade().is_none());
    Run
    
│ │ │ │  
    source§
    impl<T, A: Allocator> Weak<T, A>
    source
    pub fn new_in(alloc: A) -> Weak<T, A>
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Constructs a new Weak<T, A>, without allocating any memory, technically in the provided
│ │ │ │  allocator.
│ │ │ │ -Calling upgrade on the return value always gives None.
    
│ │ │ │ +Calling upgrade on the return value always gives None.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::sync::Weak;
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let empty: Weak<i64, _> = Weak::new_in(System);
│ │ │ │  assert!(empty.upgrade().is_none());
    Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized> Weak<T>
    1.45.0 · source
    pub unsafe fn from_raw(ptr: *const T) -> Self
    Converts a raw pointer previously created by into_raw back into Weak<T>.
    
│ │ │ │ +
    source§
    impl<T: ?Sized> Weak<T>
    1.45.0 · source
    pub unsafe fn from_raw(ptr: *const T) -> Self
    Converts a raw pointer previously created by into_raw back into Weak<T>.
    
│ │ │ │  
    This can be used to safely get a strong reference (by calling upgrade
│ │ │ │  later) or to deallocate the weak count by dropping the Weak<T>.
    
│ │ │ │  
    It takes ownership of one weak reference (with the exception of pointers created by new,
│ │ │ │  as these don’t own anything; the method still works on them).
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    The pointer must have originated from the into_raw and must still own its potential
│ │ │ │  weak reference.
    
│ │ │ │ @@ -57,17 +57,17 @@
│ │ │ │  assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap());
│ │ │ │  assert_eq!(1, Arc::weak_count(&strong));
│ │ │ │  
│ │ │ │  drop(strong);
│ │ │ │  
│ │ │ │  // Decrement the last weak count.
│ │ │ │  assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none());Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized, A: Allocator> Weak<T, A>
    1.45.0 · source
    pub fn as_ptr(&self) -> *const T
    Returns a raw pointer to the object T pointed to by this Weak<T>.
    
│ │ │ │ +
    source§
    impl<T: ?Sized, A: Allocator> Weak<T, A>
    1.45.0 · source
    pub fn as_ptr(&self) -> *const T
    Returns a raw pointer to the object T pointed to by this Weak<T>.
    
│ │ │ │  
    The pointer is valid only if there are some strong references. The pointer may be dangling,
│ │ │ │ -unaligned or even null otherwise.
    
│ │ │ │ +unaligned or even null otherwise.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  use std::ptr;
│ │ │ │  
│ │ │ │  let strong = Arc::new("hello".to_owned());
│ │ │ │  let weak = Arc::downgrade(&strong);
│ │ │ │  // Both point to the same object
│ │ │ │ @@ -75,15 +75,15 @@
│ │ │ │  // The strong here keeps it alive, so we can still access the object.
│ │ │ │  assert_eq!("hello", unsafe { &*weak.as_ptr() });
│ │ │ │  
│ │ │ │  drop(strong);
│ │ │ │  // But not any more. We can do weak.as_ptr(), but accessing the pointer would lead to
│ │ │ │  // undefined behaviour.
│ │ │ │  // assert_eq!("hello", unsafe { &*weak.as_ptr() });
    Run
    
│ │ │ │ -
    1.45.0 · source
    pub fn into_raw(self) -> *const T
    Consumes the Weak<T> and turns it into a raw pointer.
    
│ │ │ │ +
    1.45.0 · source
    pub fn into_raw(self) -> *const T
    Consumes the Weak<T> and turns it into a raw pointer.
    
│ │ │ │  
    This converts the weak pointer into a raw pointer, while still preserving the ownership of
│ │ │ │  one weak reference (the weak count is not modified by this operation). It can be turned
│ │ │ │  back into the Weak<T> with from_raw.
    
│ │ │ │  
    The same restrictions of accessing the target of the pointer as with
│ │ │ │  as_ptr apply.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::{Arc, Weak};
│ │ │ │ @@ -93,15 +93,15 @@
│ │ │ │  let raw = weak.into_raw();
│ │ │ │  
│ │ │ │  assert_eq!(1, Arc::weak_count(&strong));
│ │ │ │  assert_eq!("hello", unsafe { &*raw });
│ │ │ │  
│ │ │ │  drop(unsafe { Weak::from_raw(raw) });
│ │ │ │  assert_eq!(0, Arc::weak_count(&strong));
    Run
    
│ │ │ │ -
    source
    pub unsafe fn from_raw_in(ptr: *const T, alloc: A) -> Self
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Converts a raw pointer previously created by into_raw back into Weak<T> in the provided
│ │ │ │ +
    source
    pub unsafe fn from_raw_in(ptr: *const T, alloc: A) -> Self
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Converts a raw pointer previously created by into_raw back into Weak<T> in the provided
│ │ │ │  allocator.
    
│ │ │ │  
    This can be used to safely get a strong reference (by calling upgrade
│ │ │ │  later) or to deallocate the weak count by dropping the Weak<T>.
    
│ │ │ │  
    It takes ownership of one weak reference (with the exception of pointers created by new,
│ │ │ │  as these don’t own anything; the method still works on them).
    
│ │ │ │  
    §Safety
    
│ │ │ │  
    The pointer must have originated from the into_raw and must still own its potential
│ │ │ │ @@ -123,18 +123,18 @@
│ │ │ │  assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap());
│ │ │ │  assert_eq!(1, Arc::weak_count(&strong));
│ │ │ │  
│ │ │ │  drop(strong);
│ │ │ │  
│ │ │ │  // Decrement the last weak count.
│ │ │ │  assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none());Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized, A: Allocator> Weak<T, A>
    source
    pub fn upgrade(&self) -> Option<Arc<T, A>>
    where
│ │ │ │ -    A: Clone,
    Attempts to upgrade the Weak pointer to an Arc, delaying
│ │ │ │ +
    source§
    impl<T: ?Sized, A: Allocator> Weak<T, A>
    source
    pub fn upgrade(&self) -> Option<Arc<T, A>>
    where
│ │ │ │ +    A: Clone,
    Attempts to upgrade the Weak pointer to an Arc, delaying
│ │ │ │  dropping of the inner value if successful.
    
│ │ │ │ -
    Returns None if the inner value has since been dropped.
    
│ │ │ │ +
    Returns None if the inner value has since been dropped.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │  
│ │ │ │  let five = Arc::new(5);
│ │ │ │  
│ │ │ │  let weak_five = Arc::downgrade(&five);
│ │ │ │  
│ │ │ │ @@ -142,25 +142,25 @@
│ │ │ │  assert!(strong_five.is_some());
│ │ │ │  
│ │ │ │  // Destroy all strong pointers.
│ │ │ │  drop(strong_five);
│ │ │ │  drop(five);
│ │ │ │  
│ │ │ │  assert!(weak_five.upgrade().is_none());
    Run
    
│ │ │ │ -
    1.41.0 · source
    pub fn strong_count(&self) -> usize
    Gets the number of strong (Arc) pointers pointing to this allocation.
    
│ │ │ │ +
    1.41.0 · source
    pub fn strong_count(&self) -> usize
    Gets the number of strong (Arc) pointers pointing to this allocation.
    
│ │ │ │  
    If self was created using Weak::new, this will return 0.
    
│ │ │ │ -
    1.41.0 · source
    pub fn weak_count(&self) -> usize
    Gets an approximation of the number of Weak pointers pointing to this
│ │ │ │ +
    1.41.0 · source
    pub fn weak_count(&self) -> usize
    Gets an approximation of the number of Weak pointers pointing to this
│ │ │ │  allocation.
    
│ │ │ │  
    If self was created using Weak::new, or if there are no remaining
│ │ │ │  strong pointers, this will return 0.
    
│ │ │ │  
    §Accuracy
    
│ │ │ │  
    Due to implementation details, the returned value can be off by 1 in
│ │ │ │  either direction when other threads are manipulating any Arcs or
│ │ │ │  Weaks pointing to the same allocation.
    
│ │ │ │ -
    1.39.0 · source
    pub fn ptr_eq(&self, other: &Self) -> bool
    Returns true if the two Weaks point to the same allocation similar to ptr::eq, or if
│ │ │ │ +
    1.39.0 · source
    pub fn ptr_eq(&self, other: &Self) -> bool
    Returns true if the two Weaks point to the same allocation similar to ptr::eq, or if
│ │ │ │  both don’t point to any allocation (because they were created with Weak::new()). However,
│ │ │ │  this function ignores the metadata of  dyn Trait pointers.
    
│ │ │ │  
    §Notes
    
│ │ │ │  
    Since this compares pointers it means that Weak::new() will equal each
│ │ │ │  other, even though they don’t point to any allocation.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Arc;
│ │ │ │ @@ -182,30 +182,30 @@
│ │ │ │  let first = Weak::new();
│ │ │ │  let second = Weak::new();
│ │ │ │  assert!(first.ptr_eq(&second));
│ │ │ │  
│ │ │ │  let third_rc = Arc::new(());
│ │ │ │  let third = Arc::downgrade(&third_rc);
│ │ │ │  assert!(!first.ptr_eq(&third));
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<T: ?Sized, A: Allocator + Clone> Clone for Weak<T, A>
    source§
    fn clone(&self) -> Weak<T, A>
    Makes a clone of the Weak pointer that points to the same allocation.
    
│ │ │ │ +
    Trait Implementations§
    source§
    impl<T: ?Sized, A: Allocator + Clone> Clone for Weak<T, A>
    source§
    fn clone(&self) -> Weak<T, A>
    Makes a clone of the Weak pointer that points to the same allocation.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::{Arc, Weak};
│ │ │ │  
│ │ │ │  let weak_five = Arc::downgrade(&Arc::new(5));
│ │ │ │  
│ │ │ │  let _ = Weak::clone(&weak_five);
    Run
    
│ │ │ │ -
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<T: ?Sized> Debug for Weak<T>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    1.10.0 · source§
    impl<T> Default for Weak<T>
    source§
    fn default() -> Weak<T>
    Constructs a new Weak<T>, without allocating memory.
│ │ │ │ +
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<T: ?Sized> Debug for Weak<T>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    1.10.0 · source§
    impl<T> Default for Weak<T>
    source§
    fn default() -> Weak<T>
    Constructs a new Weak<T>, without allocating memory.
│ │ │ │  Calling upgrade on the return value always
│ │ │ │ -gives None.
    
│ │ │ │ +gives None.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::Weak;
│ │ │ │  
│ │ │ │  let empty: Weak<i64> = Default::default();
│ │ │ │  assert!(empty.upgrade().is_none());
    Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized, A: Allocator> Drop for Weak<T, A>
    source§
    fn drop(&mut self)
    Drops the Weak pointer.
    
│ │ │ │ +
    source§
    impl<T: ?Sized, A: Allocator> Drop for Weak<T, A>
    source§
    fn drop(&mut self)
    Drops the Weak pointer.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    use std::sync::{Arc, Weak};
│ │ │ │  
│ │ │ │  struct Foo;
│ │ │ │  
│ │ │ │  impl Drop for Foo {
│ │ │ │      fn drop(&mut self) {
│ │ │ │ @@ -217,25 +217,25 @@
│ │ │ │  let weak_foo = Arc::downgrade(&foo);
│ │ │ │  let other_weak_foo = Weak::clone(&weak_foo);
│ │ │ │  
│ │ │ │  drop(weak_foo);   // Doesn't print anything
│ │ │ │  drop(foo);        // Prints "dropped!"
│ │ │ │  
│ │ │ │  assert!(other_weak_foo.upgrade().is_none());
    Run
    
│ │ │ │ -
    source§
    impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Weak<U, A>> for Weak<T, A>
    source§
    impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T>
    source§
    impl<T: ?Sized + Sync + Send, A: Allocator + Send> Send for Weak<T, A>
    source§
    impl<T: ?Sized + Sync + Send, A: Allocator + Sync> Sync for Weak<T, A>
    Auto Trait Implementations§
    §
    impl<T: ?Sized, A> Freeze for Weak<T, A>
    where
│ │ │ │ -    A: Freeze,
    §
    impl<T: ?Sized, A> RefUnwindSafe for Weak<T, A>
    where
│ │ │ │ -    A: RefUnwindSafe,
│ │ │ │ -    T: RefUnwindSafe,
    §
    impl<T: ?Sized, A> Unpin for Weak<T, A>
    where
│ │ │ │ -    A: Unpin,
    §
    impl<T: ?Sized, A> UnwindSafe for Weak<T, A>
    where
│ │ │ │ -    A: UnwindSafe,
│ │ │ │ -    T: RefUnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +
    source§
    impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Weak<U, A>> for Weak<T, A>
    source§
    impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T>
    source§
    impl<T: ?Sized + Sync + Send, A: Allocator + Send> Send for Weak<T, A>
    source§
    impl<T: ?Sized + Sync + Send, A: Allocator + Sync> Sync for Weak<T, A>
    Auto Trait Implementations§
    §
    impl<T: ?Sized, A> Freeze for Weak<T, A>
    where
│ │ │ │ +    A: Freeze,
    §
    impl<T: ?Sized, A> RefUnwindSafe for Weak<T, A>
    where
│ │ │ │ +    A: RefUnwindSafe,
│ │ │ │ +    T: RefUnwindSafe,
    §
    impl<T: ?Sized, A> Unpin for Weak<T, A>
    where
│ │ │ │ +    A: Unpin,
    §
    impl<T: ?Sized, A> UnwindSafe for Weak<T, A>
    where
│ │ │ │ +    A: UnwindSafe,
│ │ │ │ +    T: RefUnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │  
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/task/trait.LocalWake.html
│ │ │ │ @@ -85,9 +85,9 @@
│ │ │ │  block_on(async {
│ │ │ │      println!("hello world");
│ │ │ │  });    Run
│ │ │ │  
    Required Methods§
    source
    fn wake(self: Rc<Self>)
    🔬This is a nightly-only experimental API. (local_waker #118959)
    Wake this task.
    
│ │ │ │  
    Provided Methods§
    source
    fn wake_by_ref(self: &Rc<Self>)
    🔬This is a nightly-only experimental API. (local_waker #118959)
    Wake this task without consuming the local waker.
    
│ │ │ │  
    If an executor supports a cheaper way to wake without consuming the
│ │ │ │  waker, it should override this method. By default, it clones the
│ │ │ │ -Rc and calls wake on the clone.
    
│ │ │ │ +Rc and calls wake on the clone.
    
│ │ │ │  
    Object Safety§
    This trait is not object safe.
    Implementors§
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/task/trait.Wake.html
│ │ │ │ @@ -2,25 +2,25 @@
│ │ │ │      
    Trait alloc::task::Wake
    1.51.0 · source · 
    pub trait Wake {
│ │ │ │      // Required method
│ │ │ │      fn wake(self: Arc<Self>);
│ │ │ │  
│ │ │ │      // Provided method
│ │ │ │      fn wake_by_ref(self: &Arc<Self>) { ... }
│ │ │ │  }
    Expand description
    The implementation of waking a task on an executor.
    
│ │ │ │ -
    This trait can be used to create a Waker. An executor can define an
│ │ │ │ -implementation of this trait, and use that to construct a Waker to pass
│ │ │ │ +
    This trait can be used to create a Waker. An executor can define an
│ │ │ │ +implementation of this trait, and use that to construct a Waker to pass
│ │ │ │  to the tasks that are executed on that executor.
    
│ │ │ │  
    This trait is a memory-safe and ergonomic alternative to constructing a
│ │ │ │ -RawWaker. It supports the common executor design in which the data used
│ │ │ │ +RawWaker. It supports the common executor design in which the data used
│ │ │ │  to wake up a task is stored in an Arc. Some executors (especially
│ │ │ │ -those for embedded systems) cannot use this API, which is why RawWaker
│ │ │ │ +those for embedded systems) cannot use this API, which is why RawWaker
│ │ │ │  exists as an alternative for those systems.
    
│ │ │ │ -
    To construct a Waker from some type W implementing this trait,
│ │ │ │ +
    To construct a Waker from some type W implementing this trait,
│ │ │ │  wrap it in an Arc<W> and call Waker::from() on that.
│ │ │ │ -It is also possible to convert to RawWaker in the same way.
    
│ │ │ │ +It is also possible to convert to RawWaker in the same way.
    
│ │ │ │  
│ │ │ │  
    §Examples
    
│ │ │ │  
    A basic block_on function that takes a future and runs it to completion on
│ │ │ │  the current thread.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/vec/index.html
│ │ │ │ @@ -22,13 +22,13 @@
│ │ │ │  
│ │ │ │  v.push(3);Run
    
│ │ │ │  
    Popping values works in much the same way:
    
│ │ │ │  
│ │ │ │  
    let mut v = vec![1, 2];
│ │ │ │  
│ │ │ │  let two = v.pop();
    Run
    
│ │ │ │ -
    Vectors also support indexing (through the Index and IndexMut traits):
    
│ │ │ │ +
    Vectors also support indexing (through the Index and IndexMut traits):
    
│ │ │ │  
│ │ │ │  
    let mut v = vec![1, 2, 3];
│ │ │ │  let three = v[2];
│ │ │ │  v[1] = v[1] + 5;
    Run
    
│ │ │ │  
    Structs§
    • Drain
      A draining iterator for Vec<T>.
    • IntoIter
      An iterator that moves out of a vector.
    • Splice
      A splicing iterator for Vec.
    • Vec
      A contiguous growable array type, written as Vec<T>, short for ‘vector’.
    • ExtractIfExperimental
      An iterator which uses a closure to determine if an element should be removed.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.Drain.html
│ │ │ │ @@ -1,22 +1,22 @@
│ │ │ │  Drain in alloc::vec - Rust
    
│ │ │ │      
    Struct alloc::vec::Drain
    1.6.0 · source · 
    pub struct Drain<'a, T: 'a, A: Allocator + 'a = Global> { /* private fields */ }
    Expand description
    A draining iterator for Vec<T>.
    
│ │ │ │  
    This struct is created by Vec::drain.
│ │ │ │  See its documentation for more.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let mut v = vec![0, 1, 2];
│ │ │ │  let iter: std::vec::Drain<'_, _> = v.drain(..);
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<'a, T, A: Allocator> Drain<'a, T, A>
    1.46.0 · source
    pub fn as_slice(&self) -> &[T]
    Returns the remaining items of this iterator as a slice.
    
│ │ │ │ +
    Implementations§
    source§
    impl<'a, T, A: Allocator> Drain<'a, T, A>
    1.46.0 · source
    pub fn as_slice(&self) -> &[T]
    Returns the remaining items of this iterator as a slice.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let mut vec = vec!['a', 'b', 'c'];
│ │ │ │  let mut drain = vec.drain(..);
│ │ │ │  assert_eq!(drain.as_slice(), &['a', 'b', 'c']);
│ │ │ │  let _ = drain.next().unwrap();
│ │ │ │  assert_eq!(drain.as_slice(), &['b', 'c']);
    Run
    
│ │ │ │ -
    source
    pub fn allocator(&self) -> &A
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Returns a reference to the underlying allocator.
    
│ │ │ │ +
    source
    pub fn allocator(&self) -> &A
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Returns a reference to the underlying allocator.
    
│ │ │ │  
    source
    pub fn keep_rest(self)
    🔬This is a nightly-only experimental API. (drain_keep_rest #101122)
    Keep unyielded elements in the source Vec.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    #![feature(drain_keep_rest)]
│ │ │ │  
│ │ │ │  let mut vec = vec!['a', 'b', 'c'];
│ │ │ │  let mut drain = vec.drain(..);
│ │ │ │  
│ │ │ │ @@ -24,218 +24,218 @@
│ │ │ │  
│ │ │ │  // This call keeps 'b' and 'c' in the vec.
│ │ │ │  drain.keep_rest();
│ │ │ │  
│ │ │ │  // If we wouldn't call `keep_rest()`,
│ │ │ │  // `vec` would be empty.
│ │ │ │  assert_eq!(vec, ['b', 'c']);
    Run
    
│ │ │ │ -
    Trait Implementations§
    1.46.0 · source§
    impl<'a, T, A: Allocator> AsRef<[T]> for Drain<'a, T, A>
    source§
    fn as_ref(&self) -> &[T]
    Converts this type into a shared reference of the (usually inferred) input type.
    1.17.0 · source§
    impl<T: Debug, A: Allocator> Debug for Drain<'_, T, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>
    source§
    fn next_back(&mut self) -> Option<T>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T, A: Allocator> Drop for Drain<'_, T, A>
    source§
    fn drop(&mut self)
    Executes the destructor for this type. Read more
    source§
    impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<T, A: Allocator> Iterator for Drain<'_, T, A>
    §
    type Item = T
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<T>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    1.46.0 · source§
    impl<'a, T, A: Allocator> AsRef<[T]> for Drain<'a, T, A>
    source§
    fn as_ref(&self) -> &[T]
    Converts this type into a shared reference of the (usually inferred) input type.
    1.17.0 · source§
    impl<T: Debug, A: Allocator> Debug for Drain<'_, T, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>
    source§
    fn next_back(&mut self) -> Option<T>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T, A: Allocator> Drop for Drain<'_, T, A>
    source§
    fn drop(&mut self)
    Executes the destructor for this type. Read more
    source§
    impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<T, A: Allocator> Iterator for Drain<'_, T, A>
    §
    type Item = T
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<T>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │  such that all those that return true precede all those that return false.
│ │ │ │ -Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
│ │ │ │ -    Self: Sized + ExactSizeIterator + DoubleEndedIterator,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ -index. Read more
    source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ -    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
│ │ │ │ +    Self: Sized + ExactSizeIterator + DoubleEndedIterator,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ +index. Read more
    source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ +    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>
    source§
    impl<T: Send, A: Send + Allocator> Send for Drain<'_, T, A>
    source§
    impl<T: Sync, A: Sync + Allocator> Sync for Drain<'_, T, A>
    source§
    impl<T, A: Allocator> TrustedLen for Drain<'_, T, A>
    Auto Trait Implementations§
    §
    impl<'a, T, A> Freeze for Drain<'a, T, A>
    §
    impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
    where
│ │ │ │ -    A: RefUnwindSafe,
│ │ │ │ -    T: RefUnwindSafe,
    §
    impl<'a, T, A> Unpin for Drain<'a, T, A>
    §
    impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
    where
│ │ │ │ -    A: RefUnwindSafe,
│ │ │ │ -    T: RefUnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>
    source§
    impl<T: Send, A: Send + Allocator> Send for Drain<'_, T, A>
    source§
    impl<T: Sync, A: Sync + Allocator> Sync for Drain<'_, T, A>
    source§
    impl<T, A: Allocator> TrustedLen for Drain<'_, T, A>
    Auto Trait Implementations§
    §
    impl<'a, T, A> Freeze for Drain<'a, T, A>
    §
    impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
    where
│ │ │ │ +    A: RefUnwindSafe,
│ │ │ │ +    T: RefUnwindSafe,
    §
    impl<'a, T, A> Unpin for Drain<'a, T, A>
    §
    impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
    where
│ │ │ │ +    A: RefUnwindSafe,
│ │ │ │ +    T: RefUnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.ExtractIf.html
│ │ │ │ @@ -1,215 +1,215 @@
│ │ │ │  ExtractIf in alloc::vec - Rust
    
│ │ │ │      
    Struct alloc::vec::ExtractIf
    source · 
    pub struct ExtractIf<'a, T, F, A: Allocator = Global>
    where
│ │ │ │ -    F: FnMut(&mut T) -> bool,
    { /* private fields */ }
    🔬This is a nightly-only experimental API. (extract_if #43244)
    Expand description
    An iterator which uses a closure to determine if an element should be removed.
    
│ │ │ │ +    F: FnMut(&mut T) -> bool,
    { /* private fields */ }
    🔬This is a nightly-only experimental API. (extract_if #43244)
    Expand description
    An iterator which uses a closure to determine if an element should be removed.
    
│ │ │ │  
    This struct is created by Vec::extract_if.
│ │ │ │  See its documentation for more.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    #![feature(extract_if)]
│ │ │ │  
│ │ │ │  let mut v = vec![0, 1, 2];
│ │ │ │  let iter: std::vec::ExtractIf<'_, _, _> = v.extract_if(|x| *x % 2 == 0);
    Run
    
│ │ │ │  
    Implementations§
    source§
    impl<T, F, A: Allocator> ExtractIf<'_, T, F, A>
    where
│ │ │ │ -    F: FnMut(&mut T) -> bool,
    source
    pub fn allocator(&self) -> &A
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Returns a reference to the underlying allocator.
    
│ │ │ │ +    F: FnMut(&mut T) -> bool,
    source
    pub fn allocator(&self) -> &A
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Returns a reference to the underlying allocator.
    
│ │ │ │  
    Trait Implementations§
    source§
    impl<'a, T: Debug, F, A: Debug + Allocator> Debug for ExtractIf<'a, T, F, A>
    where
│ │ │ │ -    F: FnMut(&mut T) -> bool + Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<T, F, A: Allocator> Drop for ExtractIf<'_, T, F, A>
    where
│ │ │ │ -    F: FnMut(&mut T) -> bool,
    source§
    fn drop(&mut self)
    Executes the destructor for this type. Read more
    source§
    impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
    where
│ │ │ │ -    F: FnMut(&mut T) -> bool,
    §
    type Item = T
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<T>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +    F: FnMut(&mut T) -> bool + Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<T, F, A: Allocator> Drop for ExtractIf<'_, T, F, A>
    where
│ │ │ │ +    F: FnMut(&mut T) -> bool,
    source§
    fn drop(&mut self)
    Executes the destructor for this type. Read more
    source§
    impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
    where
│ │ │ │ +    F: FnMut(&mut T) -> bool,
    §
    type Item = T
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<T>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    Auto Trait Implementations§
    §
    impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
    where
│ │ │ │ -    F: Freeze,
    §
    impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
    where
│ │ │ │ -    A: RefUnwindSafe,
│ │ │ │ -    F: RefUnwindSafe,
│ │ │ │ -    T: RefUnwindSafe,
    §
    impl<'a, T, F, A> Send for ExtractIf<'a, T, F, A>
    where
│ │ │ │ -    A: Send,
│ │ │ │ -    F: Send,
│ │ │ │ -    T: Send,
    §
    impl<'a, T, F, A> Sync for ExtractIf<'a, T, F, A>
    where
│ │ │ │ -    A: Sync,
│ │ │ │ -    F: Sync,
│ │ │ │ -    T: Sync,
    §
    impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
    where
│ │ │ │ -    F: Unpin,
    §
    impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    Auto Trait Implementations§
    §
    impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
    where
│ │ │ │ +    F: Freeze,
    §
    impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
    where
│ │ │ │ +    A: RefUnwindSafe,
│ │ │ │ +    F: RefUnwindSafe,
│ │ │ │ +    T: RefUnwindSafe,
    §
    impl<'a, T, F, A> Send for ExtractIf<'a, T, F, A>
    where
│ │ │ │ +    A: Send,
│ │ │ │ +    F: Send,
│ │ │ │ +    T: Send,
    §
    impl<'a, T, F, A> Sync for ExtractIf<'a, T, F, A>
    where
│ │ │ │ +    A: Sync,
│ │ │ │ +    F: Sync,
│ │ │ │ +    T: Sync,
    §
    impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
    where
│ │ │ │ +    F: Unpin,
    §
    impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.IntoIter.html
│ │ │ │ @@ -1,241 +1,241 @@
│ │ │ │  IntoIter in alloc::vec - Rust
    
│ │ │ │      
    Struct alloc::vec::IntoIter
    1.0.0 · source · 
    pub struct IntoIter<T, A: Allocator = Global> { /* private fields */ }
    Expand description
    An iterator that moves out of a vector.
    
│ │ │ │  
    This struct is created by the into_iter method on Vec
│ │ │ │ -(provided by the IntoIterator trait).
    
│ │ │ │ +(provided by the IntoIterator trait).
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let v = vec![0, 1, 2];
│ │ │ │  let iter: std::vec::IntoIter<_> = v.into_iter();
    Run
    
│ │ │ │ -
    Implementations§
    source§
    impl<T, A: Allocator> IntoIter<T, A>
    1.15.0 · source
    pub fn as_slice(&self) -> &[T]
    Returns the remaining items of this iterator as a slice.
    
│ │ │ │ +
    Implementations§
    source§
    impl<T, A: Allocator> IntoIter<T, A>
    1.15.0 · source
    pub fn as_slice(&self) -> &[T]
    Returns the remaining items of this iterator as a slice.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let vec = vec!['a', 'b', 'c'];
│ │ │ │  let mut into_iter = vec.into_iter();
│ │ │ │  assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
│ │ │ │  let _ = into_iter.next().unwrap();
│ │ │ │  assert_eq!(into_iter.as_slice(), &['b', 'c']);
    Run
    
│ │ │ │ -
    1.15.0 · source
    pub fn as_mut_slice(&mut self) -> &mut [T]
    Returns the remaining items of this iterator as a mutable slice.
    
│ │ │ │ +
    1.15.0 · source
    pub fn as_mut_slice(&mut self) -> &mut [T]
    Returns the remaining items of this iterator as a mutable slice.
    
│ │ │ │  
    §Examples
    
│ │ │ │  
    let vec = vec!['a', 'b', 'c'];
│ │ │ │  let mut into_iter = vec.into_iter();
│ │ │ │  assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
│ │ │ │  into_iter.as_mut_slice()[2] = 'z';
│ │ │ │  assert_eq!(into_iter.next().unwrap(), 'a');
│ │ │ │  assert_eq!(into_iter.next().unwrap(), 'b');
│ │ │ │  assert_eq!(into_iter.next().unwrap(), 'z');
    Run
    
│ │ │ │ -
    source
    pub fn allocator(&self) -> &A
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Returns a reference to the underlying allocator.
    
│ │ │ │ -
    Trait Implementations§
    1.46.0 · source§
    impl<T, A: Allocator> AsRef<[T]> for IntoIter<T, A>
    source§
    fn as_ref(&self) -> &[T]
    Converts this type into a shared reference of the (usually inferred) input type.
    1.8.0 · source§
    impl<T: Clone, A: Allocator + Clone> Clone for IntoIter<T, A>
    source§
    fn clone(&self) -> Self
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    1.13.0 · source§
    impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    1.70.0 · source§
    impl<T, A> Default for IntoIter<T, A>
    where
│ │ │ │ -    A: Allocator + Default,
    source§
    fn default() -> Self
    Creates an empty vec::IntoIter.
    
│ │ │ │ +
    source
    pub fn allocator(&self) -> &A
    🔬This is a nightly-only experimental API. (allocator_api #32838)
    Returns a reference to the underlying allocator.
    
│ │ │ │ +
    Trait Implementations§
    1.46.0 · source§
    impl<T, A: Allocator> AsRef<[T]> for IntoIter<T, A>
    source§
    fn as_ref(&self) -> &[T]
    Converts this type into a shared reference of the (usually inferred) input type.
    1.8.0 · source§
    impl<T: Clone, A: Allocator + Clone> Clone for IntoIter<T, A>
    source§
    fn clone(&self) -> Self
    Returns a copy of the value. Read more
    source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    1.13.0 · source§
    impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    1.70.0 · source§
    impl<T, A> Default for IntoIter<T, A>
    where
│ │ │ │ +    A: Allocator + Default,
    source§
    fn default() -> Self
    Creates an empty vec::IntoIter.
    
│ │ │ │  
│ │ │ │  
    let iter: vec::IntoIter<u8> = Default::default();
│ │ │ │  assert_eq!(iter.len(), 0);
│ │ │ │  assert_eq!(iter.as_slice(), &[]);
    Run
    
│ │ │ │ -
    source§
    impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>
    source§
    fn next_back(&mut self) -> Option<T>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T, A: Allocator> Drop for IntoIter<T, A>
    source§
    fn drop(&mut self)
    Executes the destructor for this type. Read more
    source§
    impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<T, A: Allocator> Iterator for IntoIter<T, A>
    §
    type Item = T
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<T>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn next_chunk<const N: usize>(&mut self) -> Result<[T; N], IntoIter<T, N>>
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +
    source§
    impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>
    source§
    fn next_back(&mut self) -> Option<T>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<T, A: Allocator> Drop for IntoIter<T, A>
    source§
    fn drop(&mut self)
    Executes the destructor for this type. Read more
    source§
    impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    impl<T, A: Allocator> Iterator for IntoIter<T, A>
    §
    type Item = T
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<T>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    source§
    fn count(self) -> usize
    Consumes the iterator, counting the number of iterations and returning it. Read more
    source§
    fn next_chunk<const N: usize>(&mut self) -> Result<[T; N], IntoIter<T, N>>
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    1.21.0 · source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │  such that all those that return true precede all those that return false.
│ │ │ │ -Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
│ │ │ │ -    Self: Sized + ExactSizeIterator + DoubleEndedIterator,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ -index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ -    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
│ │ │ │ +    Self: Sized + ExactSizeIterator + DoubleEndedIterator,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ +index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ +    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    1.26.0 · source§
    impl<T, A: Allocator> FusedIterator for IntoIter<T, A>
    source§
    impl<T: Send, A: Allocator + Send> Send for IntoIter<T, A>
    source§
    impl<T: Sync, A: Allocator + Sync> Sync for IntoIter<T, A>
    source§
    impl<T, A: Allocator> TrustedLen for IntoIter<T, A>
    Auto Trait Implementations§
    §
    impl<T, A> Freeze for IntoIter<T, A>
    where
│ │ │ │ -    A: Freeze,
    §
    impl<T, A> RefUnwindSafe for IntoIter<T, A>
    where
│ │ │ │ -    A: RefUnwindSafe,
│ │ │ │ -    T: RefUnwindSafe,
    §
    impl<T, A> Unpin for IntoIter<T, A>
    where
│ │ │ │ -    A: Unpin,
│ │ │ │ -    T: Unpin,
    §
    impl<T, A> UnwindSafe for IntoIter<T, A>
    where
│ │ │ │ -    A: UnwindSafe,
│ │ │ │ -    T: UnwindSafe + RefUnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    1.26.0 · source§
    impl<T, A: Allocator> FusedIterator for IntoIter<T, A>
    source§
    impl<T: Send, A: Allocator + Send> Send for IntoIter<T, A>
    source§
    impl<T: Sync, A: Allocator + Sync> Sync for IntoIter<T, A>
    source§
    impl<T, A: Allocator> TrustedLen for IntoIter<T, A>
    Auto Trait Implementations§
    §
    impl<T, A> Freeze for IntoIter<T, A>
    where
│ │ │ │ +    A: Freeze,
    §
    impl<T, A> RefUnwindSafe for IntoIter<T, A>
    where
│ │ │ │ +    A: RefUnwindSafe,
│ │ │ │ +    T: RefUnwindSafe,
    §
    impl<T, A> Unpin for IntoIter<T, A>
    where
│ │ │ │ +    A: Unpin,
│ │ │ │ +    T: Unpin,
    §
    impl<T, A> UnwindSafe for IntoIter<T, A>
    where
│ │ │ │ +    A: UnwindSafe,
│ │ │ │ +    T: UnwindSafe + RefUnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ -    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T> ToOwned for T
    where
│ │ │ │ +    T: Clone,
    §
    type Owned = T
    The resulting type after obtaining ownership.
    source§
    fn to_owned(&self) -> T
    Creates owned data from borrowed data, usually by cloning. Read more
    source§
    fn clone_into(&self, target: &mut T)
    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.Splice.html
│ │ │ │ @@ -1,230 +1,230 @@
│ │ │ │  Splice in alloc::vec - Rust
    
│ │ │ │ -    
    Struct alloc::vec::Splice
    1.21.0 · source · 
    pub struct Splice<'a, I: Iterator + 'a, A: Allocator + 'a = Global> { /* private fields */ }
    Expand description
    A splicing iterator for Vec.
    
│ │ │ │ +    
    Struct alloc::vec::Splice
    1.21.0 · source · 
    pub struct Splice<'a, I: Iterator + 'a, A: Allocator + 'a = Global> { /* private fields */ }
    Expand description
    A splicing iterator for Vec.
    
│ │ │ │  
    This struct is created by Vec::splice().
│ │ │ │  See its documentation for more.
    
│ │ │ │  
    §Example
    
│ │ │ │  
    let mut v = vec![0, 1, 2];
│ │ │ │  let new = [7, 8];
│ │ │ │  let iter: std::vec::Splice<'_, _> = v.splice(1.., new);
    Run
    
│ │ │ │ -
    Trait Implementations§
    source§
    impl<'a, I: Debug + Iterator + 'a, A: Debug + Allocator + 'a> Debug for Splice<'a, I, A>
    where
│ │ │ │ -    I::Item: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<I: Iterator, A: Allocator> DoubleEndedIterator for Splice<'_, I, A>
    source§
    fn next_back(&mut self) -> Option<Self::Item>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ -elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ -final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<I: Iterator, A: Allocator> Drop for Splice<'_, I, A>
    source§
    fn drop(&mut self)
    Executes the destructor for this type. Read more
    source§
    impl<I: Iterator, A: Allocator> ExactSizeIterator for Splice<'_, I, A>
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<I: Iterator, A: Allocator> Iterator for Splice<'_, I, A>
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<Self::Item>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │ +
    Trait Implementations§
    source§
    impl<'a, I: Debug + Iterator + 'a, A: Debug + Allocator + 'a> Debug for Splice<'a, I, A>
    where
│ │ │ │ +    I::Item: Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<I: Iterator, A: Allocator> DoubleEndedIterator for Splice<'_, I, A>
    source§
    fn next_back(&mut self) -> Option<Self::Item>
    Removes and returns an element from the end of the iterator. Read more
    source§
    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator from the back by n elements. Read more
    1.37.0 · source§
    fn nth_back(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element from the end of the iterator. Read more
    1.27.0 · source§
    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    This is the reverse version of Iterator::try_fold(): it takes
│ │ │ │ +elements starting from the back of the iterator. Read more
    1.27.0 · source§
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    An iterator method that reduces the iterator’s elements to a single,
│ │ │ │ +final value, starting from the back. Read more
    1.27.0 · source§
    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator from the back that satisfies a predicate. Read more
    source§
    impl<I: Iterator, A: Allocator> Drop for Splice<'_, I, A>
    source§
    fn drop(&mut self)
    Executes the destructor for this type. Read more
    source§
    impl<I: Iterator, A: Allocator> ExactSizeIterator for Splice<'_, I, A>
    1.0.0 · source§
    fn len(&self) -> usize
    Returns the exact remaining length of the iterator. Read more
    source§
    fn is_empty(&self) -> bool
    🔬This is a nightly-only experimental API. (exact_size_is_empty #35428)
    Returns true if the iterator is empty. Read more
    source§
    impl<I: Iterator, A: Allocator> Iterator for Splice<'_, I, A>
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    source§
    fn next(&mut self) -> Option<Self::Item>
    Advances the iterator and returns the next value. Read more
    source§
    fn size_hint(&self) -> (usize, Option<usize>)
    Returns the bounds on the remaining length of the iterator. Read more
    source§
    fn next_chunk<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ -the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ -between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ -element. Read more
    source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ -should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ -the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │ +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_next_chunk #98326)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§
    fn count(self) -> usize
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§
    fn last(self) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
    Consumes the iterator, returning the last element. Read more
    source§
    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
    🔬This is a nightly-only experimental API. (iter_advance_by #77404)
    Advances the iterator by n elements. Read more
    1.0.0 · source§
    fn nth(&mut self, n: usize) -> Option<Self::Item>
    Returns the nth element of the iterator. Read more
    1.28.0 · source§
    fn step_by(self, step: usize) -> StepBy<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator starting at the same point, but stepping by
│ │ │ │ +the given amount at each iteration. Read more
    1.0.0 · source§
    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator<Item = Self::Item>,
    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§
    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    G: FnMut() -> Self::Item,
    🔬This is a nightly-only experimental API. (iter_intersperse #79524)
    Creates a new iterator which places an item generated by separator
│ │ │ │ +between adjacent items of the original iterator. Read more
    1.0.0 · source§
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> B,
    Takes a closure and creates an iterator which calls that closure on each
│ │ │ │ +element. Read more
    source§
    fn for_each<F>(self, f: F)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item),
    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§
    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator which uses a closure to determine if an element
│ │ │ │ +should be yielded. Read more
    1.0.0 · source§
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§
    fn enumerate(self) -> Enumerate<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which gives the current iteration count as well as
│ │ │ │ +the next value. Read more
    1.0.0 · source§
    fn peekable(self) -> Peekable<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which can use the peek and peek_mut methods
│ │ │ │  to look at the next element of the iterator without consuming it. See
│ │ │ │ -their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ -if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ -unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    U: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ -self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ -the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ -    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ -    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ -    B: FromIterator<Self::Item>,
│ │ │ │ -    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ -    E: Extend<Self::Item>,
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    B: Default + Extend<Self::Item>,
│ │ │ │ -    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │ +their documentation for more information. Read more
    1.0.0 · source§
    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§
    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§
    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> Option<B>,
    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§
    fn skip(self, n: usize) -> Skip<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§
    fn take(self, n: usize) -> Take<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator that yields the first n elements, or fewer
│ │ │ │ +if the underlying iterator ends sooner. Read more
    1.0.0 · source§
    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&mut St, Self::Item) -> Option<B>,
    An iterator adapter which, like fold, holds internal state, but
│ │ │ │ +unlike fold, produces a new iterator. Read more
    1.0.0 · source§
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    U: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item) -> U,
    Creates an iterator that works like map, but flattens nested structure. Read more
    source§
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&[Self::Item; N]) -> R,
    🔬This is a nightly-only experimental API. (iter_map_windows #87155)
    Calls the given function f for each contiguous window of size N over
│ │ │ │ +self and returns an iterator over the outputs of f. Like slice::windows(),
│ │ │ │ +the windows during mapping overlap as well. Read more
    1.0.0 · source§
    fn fuse(self) -> Fuse<Self>
    where
│ │ │ │ +    Self: Sized,
    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item),
    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§
    fn by_ref(&mut self) -> &mut Self
    where
│ │ │ │ +    Self: Sized,
    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§
    fn collect<B>(self) -> B
    where
│ │ │ │ +    B: FromIterator<Self::Item>,
│ │ │ │ +    Self: Sized,
    Transforms an iterator into a collection. Read more
    source§
    fn collect_into<E>(self, collection: &mut E) -> &mut E
    where
│ │ │ │ +    E: Extend<Self::Item>,
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_collect_into #94780)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§
    fn partition<B, F>(self, f: F) -> (B, B)
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    B: Default + Extend<Self::Item>,
│ │ │ │ +    F: FnMut(&Self::Item) -> bool,
    Consumes an iterator, creating two collections from it. Read more
    source§
    fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
    where
│ │ │ │      T: 'a,
│ │ │ │ -    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ -    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │ +    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
│ │ │ │ +    P: FnMut(&T) -> bool,
    🔬This is a nightly-only experimental API. (iter_partition_in_place #62543)
    Reorders the elements of this iterator in-place according to the given predicate,
│ │ │ │  such that all those that return true precede all those that return false.
│ │ │ │ -Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ -such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ -successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> R,
│ │ │ │ -    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ -iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ -returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ -operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │ +Returns the number of true elements found. Read more
    source§
    fn is_partitioned<P>(self, predicate: P) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_is_partitioned #62544)
    Checks if the elements of this iterator are partitioned according to the given predicate,
│ │ │ │ +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§
    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = B>,
    An iterator method that applies a function as long as it returns
│ │ │ │ +successfully, producing a single, final value. Read more
    1.27.0 · source§
    fn try_for_each<F, R>(&mut self, f: F) -> R
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> R,
│ │ │ │ +    R: Try<Output = ()>,
    An iterator method that applies a fallible function to each item in the
│ │ │ │ +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§
    fn fold<B, F>(self, init: B, f: F) -> B
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(B, Self::Item) -> B,
    Folds every element into an accumulator by applying an operation,
│ │ │ │ +returning the final result. Read more
    1.51.0 · source§
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> Self::Item,
    Reduces the elements to a single one, by repeatedly applying a reducing
│ │ │ │ +operation. Read more
    source§
    fn try_reduce<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ -    R: Try<Output = Self::Item>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ -closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ -the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item, Self::Item) -> R,
│ │ │ │ +    R: Try<Output = Self::Item>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (iterator_try_reduce #87053)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the
│ │ │ │ +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§
    fn all<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn any<F>(&mut self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> bool,
    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(&Self::Item) -> bool,
    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§
    fn find_map<B, F>(&mut self, f: F) -> Option<B>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> Option<B>,
    Applies function to the elements of iterator and returns
│ │ │ │ +the first non-none result. Read more
    source§
    fn try_find<F, R>(
│ │ │ │      &mut self,
│ │ │ │      f: F
│ │ │ │ -) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> R,
│ │ │ │ -    R: Try<Output = bool>,
│ │ │ │ -    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ -the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ -    P: FnMut(Self::Item) -> bool,
│ │ │ │ -    Self: Sized + ExactSizeIterator + DoubleEndedIterator,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ -index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ -    B: Ord,
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ -specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ -specified comparison function. Read more
    1.0.0 · source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ -    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ -    FromA: Default + Extend<A>,
│ │ │ │ -    FromB: Default + Extend<B>,
│ │ │ │ -    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ -    T: 'a + Copy,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ -    T: 'a + Clone,
│ │ │ │ -    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ -    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ -this Iterator with those of another. The comparison works like short-circuit
│ │ │ │ +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> R,
│ │ │ │ +    R: Try<Output = bool>,
│ │ │ │ +    <R as Try>::Residual: Residual<Option<Self::Item>>,
    🔬This is a nightly-only experimental API. (try_find #63178)
    Applies function to the elements of iterator and returns
│ │ │ │ +the first true result or the first error. Read more
    1.0.0 · source§
    fn position<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
    Searches for an element in an iterator, returning its index. Read more
    1.0.0 · source§
    fn rposition<P>(&mut self, predicate: P) -> Option<usize>
    where
│ │ │ │ +    P: FnMut(Self::Item) -> bool,
│ │ │ │ +    Self: Sized + ExactSizeIterator + DoubleEndedIterator,
    Searches for an element in an iterator from the right, returning its
│ │ │ │ +index. Read more
    1.6.0 · source§
    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the maximum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the maximum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.6.0 · source§
    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
    where
│ │ │ │ +    B: Ord,
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item) -> B,
    Returns the element that gives the minimum value from the
│ │ │ │ +specified function. Read more
    1.15.0 · source§
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    Returns the element that gives the minimum value with respect to the
│ │ │ │ +specified comparison function. Read more
    1.0.0 · source§
    fn rev(self) -> Rev<Self>
    where
│ │ │ │ +    Self: Sized + DoubleEndedIterator,
    Reverses an iterator’s direction. Read more
    1.0.0 · source§
    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
    where
│ │ │ │ +    FromA: Default + Extend<A>,
│ │ │ │ +    FromB: Default + Extend<B>,
│ │ │ │ +    Self: Sized + Iterator<Item = (A, B)>,
    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§
    fn copied<'a, T>(self) -> Copied<Self>
    where
│ │ │ │ +    T: 'a + Copy,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
│ │ │ │ +    T: 'a + Clone,
│ │ │ │ +    Self: Sized + Iterator<Item = &'a T>,
    Creates an iterator which clones all of its elements. Read more
    source§
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
│ │ │ │ +    Self: Sized,
    🔬This is a nightly-only experimental API. (iter_array_chunks #100450)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§
    fn sum<S>(self) -> S
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    S: Sum<Self::Item>,
    Sums the elements of an iterator. Read more
    1.11.0 · source§
    fn product<P>(self) -> P
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    P: Product<Self::Item>,
    Iterates over the entire iterator, multiplying all the elements Read more
    source§
    fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Lexicographically compares the PartialOrd elements of
│ │ │ │ +this Iterator with those of another. The comparison works like short-circuit
│ │ │ │  evaluation, returning a result without comparing the remaining elements.
│ │ │ │ -As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ -of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ -another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ -another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ -    I: IntoIterator,
│ │ │ │ -    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ -    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ -greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ -    Self: Sized,
│ │ │ │ -    F: FnMut(Self::Item) -> K,
│ │ │ │ -    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ -function. Read more
    Auto Trait Implementations§
    §
    impl<'a, I, A> Freeze for Splice<'a, I, A>
    where
│ │ │ │ -    I: Freeze,
    §
    impl<'a, I, A> RefUnwindSafe for Splice<'a, I, A>
    where
│ │ │ │ -    A: RefUnwindSafe,
│ │ │ │ -    I: RefUnwindSafe,
│ │ │ │ -    <I as Iterator>::Item: RefUnwindSafe,
    §
    impl<'a, I, A> Send for Splice<'a, I, A>
    where
│ │ │ │ -    A: Send,
│ │ │ │ -    I: Send,
│ │ │ │ -    <I as Iterator>::Item: Send,
    §
    impl<'a, I, A> Sync for Splice<'a, I, A>
    where
│ │ │ │ -    A: Sync,
│ │ │ │ -    I: Sync,
│ │ │ │ -    <I as Iterator>::Item: Sync,
    §
    impl<'a, I, A> Unpin for Splice<'a, I, A>
    where
│ │ │ │ -    I: Unpin,
    §
    impl<'a, I, A> UnwindSafe for Splice<'a, I, A>
    where
│ │ │ │ -    A: RefUnwindSafe,
│ │ │ │ -    I: UnwindSafe,
│ │ │ │ -    <I as Iterator>::Item: RefUnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ -    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ -    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ -
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ -    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │ +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§
    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Lexicographically compares the elements of this Iterator with those
│ │ │ │ +of another with respect to the specified comparison function. Read more
    1.5.0 · source§
    fn eq<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another. Read more
    source§
    fn eq_by<I, F>(self, other: I, eq: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
    🔬This is a nightly-only experimental API. (iter_order_by #64295)
    Determines if the elements of this Iterator are equal to those of
│ │ │ │ +another with respect to the specified equality function. Read more
    1.5.0 · source§
    fn ne<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialEq<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are not equal to those of
│ │ │ │ +another. Read more
    1.5.0 · source§
    fn lt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less than those of another. Read more
    1.5.0 · source§
    fn le<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +less or equal to those of another. Read more
    1.5.0 · source§
    fn gt<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than those of another. Read more
    1.5.0 · source§
    fn ge<I>(self, other: I) -> bool
    where
│ │ │ │ +    I: IntoIterator,
│ │ │ │ +    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
│ │ │ │ +    Self: Sized,
    Determines if the elements of this Iterator are lexicographically
│ │ │ │ +greater than or equal to those of another. Read more
    source§
    fn is_sorted_by<F>(self, compare: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(&Self::Item, &Self::Item) -> bool,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§
    fn is_sorted_by_key<F, K>(self, f: F) -> bool
    where
│ │ │ │ +    Self: Sized,
│ │ │ │ +    F: FnMut(Self::Item) -> K,
│ │ │ │ +    K: PartialOrd,
    🔬This is a nightly-only experimental API. (is_sorted #53485)
    Checks if the elements of this iterator are sorted using the given key extraction
│ │ │ │ +function. Read more
    Auto Trait Implementations§
    §
    impl<'a, I, A> Freeze for Splice<'a, I, A>
    where
│ │ │ │ +    I: Freeze,
    §
    impl<'a, I, A> RefUnwindSafe for Splice<'a, I, A>
    where
│ │ │ │ +    A: RefUnwindSafe,
│ │ │ │ +    I: RefUnwindSafe,
│ │ │ │ +    <I as Iterator>::Item: RefUnwindSafe,
    §
    impl<'a, I, A> Send for Splice<'a, I, A>
    where
│ │ │ │ +    A: Send,
│ │ │ │ +    I: Send,
│ │ │ │ +    <I as Iterator>::Item: Send,
    §
    impl<'a, I, A> Sync for Splice<'a, I, A>
    where
│ │ │ │ +    A: Sync,
│ │ │ │ +    I: Sync,
│ │ │ │ +    <I as Iterator>::Item: Sync,
    §
    impl<'a, I, A> Unpin for Splice<'a, I, A>
    where
│ │ │ │ +    I: Unpin,
    §
    impl<'a, I, A> UnwindSafe for Splice<'a, I, A>
    where
│ │ │ │ +    A: RefUnwindSafe,
│ │ │ │ +    I: UnwindSafe,
│ │ │ │ +    <I as Iterator>::Item: RefUnwindSafe,
    Blanket Implementations§
    source§
    impl<T> Any for T
    where
│ │ │ │ +    T: 'static + ?Sized,
    source§
    fn type_id(&self) -> TypeId
    Gets the TypeId of self. Read more
    source§
    impl<T> Borrow<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow(&self) -> &T
    Immutably borrows from an owned value. Read more
    source§
    impl<T> BorrowMut<T> for T
    where
│ │ │ │ +    T: ?Sized,
    source§
    fn borrow_mut(&mut self) -> &mut T
    Mutably borrows from an owned value. Read more
    source§
    impl<T> From<T> for T
    source§
    fn from(t: T) -> T
    Returns the argument unchanged.
    
│ │ │ │ +
    source§
    impl<T, U> Into<U> for T
    where
│ │ │ │ +    U: From<T>,
    source§
    fn into(self) -> U
    Calls U::from(self).
    
│ │ │ │  
    That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
    
│ │ │ │ -
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ -    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ -    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ -    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ │ +From<T> for U chooses to do.
    
│ │ │ │ +
    source§
    impl<I> IntoIterator for I
    where
│ │ │ │ +    I: Iterator,
    §
    type Item = <I as Iterator>::Item
    The type of the elements being iterated over.
    §
    type IntoIter = I
    Which kind of iterator are we turning this into?
    const: unstable · source§
    fn into_iter(self) -> I
    Creates an iterator from a value. Read more
    source§
    impl<T, U> TryFrom<U> for T
    where
│ │ │ │ +    U: Into<T>,
    §
    type Error = Infallible
    The type returned in the event of a conversion error.
    source§
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
    Performs the conversion.
    source§
    impl<T, U> TryInto<U> for T
    where
│ │ │ │ +    U: TryFrom<T>,
    §
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    source§
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
    Performs the conversion.
    
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/alloc/vec/struct.Vec.html
│ │ │ │ @@ -49,28 +49,28 @@
│ │ │ │  
│ │ │ │  while let Some(top) = stack.pop() {
│ │ │ │      // Prints 3, 2, 1
│ │ │ │      println!("{top}");
│ │ │ │  }    Run
│ │ │ │  
    §Indexing
    
│ │ │ │  
    The Vec type allows access to values by index, because it implements the
│ │ │ │ -Index trait. An example will be more explicit:
    
│ │ │ │ +Index trait. An example will be more explicit:
    
│ │ │ │  
│ │ │ │  
    let v = vec![0, 2, 4, 6];
│ │ │ │  println!("{}", v[1]); // it will display '2'
    Run
    
│ │ │ │  
    However be careful: if you try to access an index which isn’t in the Vec,
│ │ │ │  your software will panic! You cannot do this:
    
│ │ │ │  
│ │ │ │  
    ⓘ
    let v = vec![0, 2, 4, 6];
│ │ │ │  println!("{}", v[6]); // it will panic!
    Run
    
│ │ │ │ -
    Use get and get_mut if you want to check whether the index is in
│ │ │ │ +
    Use get and get_mut if you want to check whether the index is in
│ │ │ │  the Vec.
    
│ │ │ │  
    §Slicing
    
│ │ │ │  
    A Vec can be mutable. On the other hand, slices are read-only objects.
│ │ │ │ -To get a slice, use &. Example:
    
│ │ │ │ +To get a slice, use &. Example:
    
│ │ │ │  
│ │ │ │  
    fn read_slice(slice: &[usize]) {
│ │ │ │      // ...
│ │ │ │  }
│ │ │ │  
│ │ │ │  let v = vec![0, 1];
│ │ │ │  read_slice(&v);
│ │ │ │ @@ -78,15 +78,15 @@
│ │ │ │  // ... and that's all!
│ │ │ │  // you can also do it like this:
│ │ │ │  let u: &[usize] = &v;
│ │ │ │  // or like this:
│ │ │ │  let u: &[_] = &v;
    Run
    
│ │ │ │  
    In Rust, it’s more common to pass slices as arguments rather than vectors
│ │ │ │  when you just want to provide read access. The same goes for String and
│ │ │ │ -&str.
    
│ │ │ │ +&str.
    
│ │ │ │  
    §Capacity and reallocation
    
│ │ │ │  
    The capacity of a vector is the amount of space allocated for any future
│ │ │ │  elements that will be added onto the vector. This is not to be confused with
│ │ │ │  the length of a vector, which specifies the number of actual elements
│ │ │ │  within the vector. If a vector’s length exceeds its capacity, its capacity
│ │ │ │  will automatically be increased, but its elements will have to be
│ │ │ │  reallocated.
    
│ │ │ │ @@ -109,15 +109,15 @@
│ │ │ │  The pointer will never be null, so this type is null-pointer-optimized.
    
│ │ │ │  
    However, the pointer might not actually point to allocated memory. In particular,
│ │ │ │  if you construct a Vec with capacity 0 via Vec::new, vec![],
│ │ │ │  Vec::with_capacity(0), or by calling shrink_to_fit
│ │ │ │  on an empty Vec, it will not allocate memory. Similarly, if you store zero-sized
│ │ │ │  types inside a Vec, it will not allocate space for them. Note that in this case
│ │ │ │  the Vec might not report a capacity of 0. Vec will allocate if and only
│ │ │ │ -if mem::size_of::<T>() * capacity() > 0. In general, Vec’s allocation
│ │ │ │ +if mem::size_of::<T>() * capacity() > 0. In general, Vec’s allocation
│ │ │ │  details are very subtle — if you intend to allocate memory using a Vec
│ │ │ │  and use it for something else (either to pass to unsafe code, or to build your
│ │ │ │  own memory-backed collection), be sure to deallocate this memory by using
│ │ │ │  from_raw_parts to recover the Vec and then dropping it.
    
│ │ │ │  
    If a Vec has allocated memory, then the memory it points to is on the heap
│ │ │ │  (as defined by the allocator Rust is configured to use by default), and its
│ │ │ │  pointer points to len initialized, contiguous elements in order (what
│ │ │ │ @@ -134,15 +134,15 @@
│ │ │ │              |
│ │ │ │              v
│ │ │ │  Heap   +--------+--------+--------+--------+
│ │ │ │         |    'a' |    'b' | uninit | uninit |
│ │ │ │         +--------+--------+--------+--------+
│ │ │ │  
│ │ │ │  
      
│ │ │ │ -
    • uninit represents memory that is not initialized, see MaybeUninit.
      • 
│ │ │ │ +
    • uninit represents memory that is not initialized, see MaybeUninit.
      • 
│ │ │ │  
    • Note: the ABI is not stable and Vec makes no guarantees about its memory
│ │ │ │  layout (including the order of fields).
      • 
│ │ │ │  
    
│ │ │ │  
    Vec will never perform a “small optimization” where elements are actually
│ │ │ │  stored on the stack for two reasons:
    
│ │ │ │  
      
│ │ │ │  
    • 
│ │ │ │ @@ -188,15 +188,15 @@
│ │ │ │  and then increasing the length to match, is always valid.
      
│ │ │ │  
      Currently, Vec does not guarantee the order in which elements are dropped.
│ │ │ │  The order has changed in the past and may change again.
      
│ │ │ │  
      Implementations§
      source§
      impl<T> Vec<T>
      const: 1.39.0 · source
      pub const fn new() -> Self
      Constructs a new, empty Vec<T>.
      
│ │ │ │  
      The vector will not allocate until elements are pushed onto it.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec: Vec<i32> = Vec::new();
      Run
      
│ │ │ │ -
      source
      pub fn with_capacity(capacity: usize) -> Self
      Constructs a new, empty Vec<T> with at least the specified capacity.
      
│ │ │ │ +
      source
      pub fn with_capacity(capacity: usize) -> Self
      Constructs a new, empty Vec<T> with at least the specified capacity.
      
│ │ │ │  
      The vector will be able to hold at least capacity elements without
│ │ │ │  reallocating. This method is allowed to allocate for more elements than
│ │ │ │  capacity. If capacity is 0, the vector will not allocate.
      
│ │ │ │  
      It is important to note that although the returned vector has the
│ │ │ │  minimum capacity specified, the vector will have a zero length. For
│ │ │ │  an explanation of the difference between length and capacity, see
│ │ │ │  Capacity and reallocation.
      
│ │ │ │ @@ -225,25 +225,25 @@
│ │ │ │  assert_eq!(vec.len(), 11);
│ │ │ │  assert!(vec.capacity() >= 11);
│ │ │ │  
│ │ │ │  // A vector of a zero-sized type will always over-allocate, since no
│ │ │ │  // allocation is necessary
│ │ │ │  let vec_units = Vec::<()>::with_capacity(10);
│ │ │ │  assert_eq!(vec_units.capacity(), usize::MAX);Run
      
│ │ │ │ -
      source
      pub fn try_with_capacity(capacity: usize) -> Result<Self, TryReserveError>
      🔬This is a nightly-only experimental API. (try_with_capacity #91913)
      Constructs a new, empty Vec<T> with at least the specified capacity.
      
│ │ │ │ +
      source
      pub fn try_with_capacity(capacity: usize) -> Result<Self, TryReserveError>
      🔬This is a nightly-only experimental API. (try_with_capacity #91913)
      Constructs a new, empty Vec<T> with at least the specified capacity.
      
│ │ │ │  
      The vector will be able to hold at least capacity elements without
│ │ │ │  reallocating. This method is allowed to allocate for more elements than
│ │ │ │  capacity. If capacity is 0, the vector will not allocate.
      
│ │ │ │  
      §Errors
      
│ │ │ │  
      Returns an error if the capacity exceeds isize::MAX bytes,
│ │ │ │  or if the allocator reports allocation failure.
      
│ │ │ │  
      source
      pub unsafe fn from_raw_parts(
│ │ │ │ -    ptr: *mut T,
│ │ │ │ -    length: usize,
│ │ │ │ -    capacity: usize
│ │ │ │ +    ptr: *mut T,
│ │ │ │ +    length: usize,
│ │ │ │ +    capacity: usize
│ │ │ │  ) -> Self
      Creates a Vec<T> directly from a pointer, a length, and a capacity.
      
│ │ │ │  
      §Safety
      
│ │ │ │  
      This is highly unsafe, due to the number of invariants that aren’t
│ │ │ │  checked:
      
│ │ │ │  
        
│ │ │ │  
      • ptr must have been allocated using the global allocator, such as via
│ │ │ │  the alloc::alloc function.
        • 
│ │ │ │ @@ -254,15 +254,15 @@
│ │ │ │  
      • The size of T times the capacity (ie. the allocated size in bytes) needs
│ │ │ │  to be the same size as the pointer was allocated with. (Because similar to
│ │ │ │  alignment, dealloc must be called with the same layout size.)
        • 
│ │ │ │  
      • length needs to be less than or equal to capacity.
        • 
│ │ │ │  
      • The first length values must be properly initialized values of type T.
        • 
│ │ │ │  
      • capacity needs to be the capacity that the pointer was allocated with.
        • 
│ │ │ │  
      • The allocated size in bytes must be no larger than isize::MAX.
│ │ │ │ -See the safety documentation of pointer::offset.
        • 
│ │ │ │ +See the safety documentation of pointer::offset.
│ │ │ │  
      
│ │ │ │  
      These requirements are always upheld by any ptr that has been allocated
│ │ │ │  via Vec<T>. Other allocation sources are allowed if the invariants are
│ │ │ │  upheld.
      
│ │ │ │  
      Violating these may cause problems like corrupting the allocator’s
│ │ │ │  internal data structures. For example it is normally not safe
│ │ │ │  to build a Vec<u8> from a pointer to a C char array with length
│ │ │ │ @@ -329,15 +329,15 @@
│ │ │ │  
      The vector will not allocate until elements are pushed onto it.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let mut vec: Vec<i32, _> = Vec::new_in(System);
      Run
      
│ │ │ │ -
      source
      pub fn with_capacity_in(capacity: usize, alloc: A) -> Self
      🔬This is a nightly-only experimental API. (allocator_api #32838)
      Constructs a new, empty Vec<T, A> with at least the specified capacity
│ │ │ │ +
      source
      pub fn with_capacity_in(capacity: usize, alloc: A) -> Self
      🔬This is a nightly-only experimental API. (allocator_api #32838)
      Constructs a new, empty Vec<T, A> with at least the specified capacity
│ │ │ │  with the provided allocator.
      
│ │ │ │  
      The vector will be able to hold at least capacity elements without
│ │ │ │  reallocating. This method is allowed to allocate for more elements than
│ │ │ │  capacity. If capacity is 0, the vector will not allocate.
      
│ │ │ │  
      It is important to note that although the returned vector has the
│ │ │ │  minimum capacity specified, the vector will have a zero length. For
│ │ │ │  an explanation of the difference between length and capacity, see
│ │ │ │ @@ -372,28 +372,28 @@
│ │ │ │  assert!(vec.capacity() >= 11);
│ │ │ │  
│ │ │ │  // A vector of a zero-sized type will always over-allocate, since no
│ │ │ │  // allocation is necessary
│ │ │ │  let vec_units = Vec::<(), System>::with_capacity_in(10, System);
│ │ │ │  assert_eq!(vec_units.capacity(), usize::MAX);Run
      
│ │ │ │  
      source
      pub fn try_with_capacity_in(
│ │ │ │ -    capacity: usize,
│ │ │ │ +    capacity: usize,
│ │ │ │      alloc: A
│ │ │ │ -) -> Result<Self, TryReserveError>
      🔬This is a nightly-only experimental API. (allocator_api #32838)
      Constructs a new, empty Vec<T, A> with at least the specified capacity
│ │ │ │ +) -> Result<Self, TryReserveError>
      🔬This is a nightly-only experimental API. (allocator_api #32838)
      Constructs a new, empty Vec<T, A> with at least the specified capacity
│ │ │ │  with the provided allocator.
      
│ │ │ │  
      The vector will be able to hold at least capacity elements without
│ │ │ │  reallocating. This method is allowed to allocate for more elements than
│ │ │ │  capacity. If capacity is 0, the vector will not allocate.
      
│ │ │ │  
      §Errors
      
│ │ │ │  
      Returns an error if the capacity exceeds isize::MAX bytes,
│ │ │ │  or if the allocator reports allocation failure.
      
│ │ │ │  
      source
      pub unsafe fn from_raw_parts_in(
│ │ │ │ -    ptr: *mut T,
│ │ │ │ -    length: usize,
│ │ │ │ -    capacity: usize,
│ │ │ │ +    ptr: *mut T,
│ │ │ │ +    length: usize,
│ │ │ │ +    capacity: usize,
│ │ │ │      alloc: A
│ │ │ │  ) -> Self
      🔬This is a nightly-only experimental API. (allocator_api #32838)
      Creates a Vec<T, A> directly from a pointer, a length, a capacity,
│ │ │ │  and an allocator.
      
│ │ │ │  
      §Safety
      
│ │ │ │  
      This is highly unsafe, due to the number of invariants that aren’t
│ │ │ │  checked:
      
│ │ │ │  
        
│ │ │ │ @@ -405,15 +405,15 @@
│ │ │ │  
      • The size of T times the capacity (ie. the allocated size in bytes) needs
│ │ │ │  to be the same size as the pointer was allocated with. (Because similar to
│ │ │ │  alignment, dealloc must be called with the same layout size.)
        • 
│ │ │ │  
      • length needs to be less than or equal to capacity.
        • 
│ │ │ │  
      • The first length values must be properly initialized values of type T.
        • 
│ │ │ │  
      • capacity needs to fit the layout size that the pointer was allocated with.
        • 
│ │ │ │  
      • The allocated size in bytes must be no larger than isize::MAX.
│ │ │ │ -See the safety documentation of pointer::offset.
        • 
│ │ │ │ +See the safety documentation of pointer::offset.
│ │ │ │  
      
│ │ │ │  
      These requirements are always upheld by any ptr that has been allocated
│ │ │ │  via Vec<T, A>. Other allocation sources are allowed if the invariants are
│ │ │ │  upheld.
      
│ │ │ │  
      Violating these may cause problems like corrupting the allocator’s
│ │ │ │  internal data structures. For example it is not safe
│ │ │ │  to build a Vec<u8> from a pointer to a C char array with length size_t.
│ │ │ │ @@ -478,15 +478,15 @@
│ │ │ │  
│ │ │ │          Vec::from_raw_parts_in(mem, 1, 16, Global)
│ │ │ │      };
│ │ │ │  
│ │ │ │      assert_eq!(vec, &[1_000_000]);
│ │ │ │      assert_eq!(vec.capacity(), 16);
│ │ │ │  }Run
      
│ │ │ │ -
      source
      pub fn into_raw_parts(self) -> (*mut T, usize, usize)
      🔬This is a nightly-only experimental API. (vec_into_raw_parts #65816)
      Decomposes a Vec<T> into its raw components: (pointer, length, capacity).
      
│ │ │ │ +
      source
      pub fn into_raw_parts(self) -> (*mut T, usize, usize)
      🔬This is a nightly-only experimental API. (vec_into_raw_parts #65816)
      Decomposes a Vec<T> into its raw components: (pointer, length, capacity).
      
│ │ │ │  
      Returns the raw pointer to the underlying data, the length of
│ │ │ │  the vector (in elements), and the allocated capacity of the
│ │ │ │  data (in elements). These are the same arguments in the same
│ │ │ │  order as the arguments to from_raw_parts.
      
│ │ │ │  
      After calling this function, the caller is responsible for the
│ │ │ │  memory previously managed by the Vec. The only way to do
│ │ │ │  this is to convert the raw pointer, length, and capacity back
│ │ │ │ @@ -502,15 +502,15 @@
│ │ │ │      // We can now make changes to the components, such as
│ │ │ │      // transmuting the raw pointer to a compatible type.
│ │ │ │      let ptr = ptr as *mut u32;
│ │ │ │  
│ │ │ │      Vec::from_raw_parts(ptr, len, cap)
│ │ │ │  };
│ │ │ │  assert_eq!(rebuilt, [4294967295, 0, 1]);Run
      
│ │ │ │ -
      source
      pub fn into_raw_parts_with_alloc(self) -> (*mut T, usize, usize, A)
      🔬This is a nightly-only experimental API. (allocator_api #32838)
      Decomposes a Vec<T> into its raw components: (pointer, length, capacity, allocator).
      
│ │ │ │ +
      source
      pub fn into_raw_parts_with_alloc(self) -> (*mut T, usize, usize, A)
      🔬This is a nightly-only experimental API. (allocator_api #32838)
      Decomposes a Vec<T> into its raw components: (pointer, length, capacity, allocator).
      
│ │ │ │  
      Returns the raw pointer to the underlying data, the length of the vector (in elements),
│ │ │ │  the allocated capacity of the data (in elements), and the allocator. These are the same
│ │ │ │  arguments in the same order as the arguments to from_raw_parts_in.
      
│ │ │ │  
      After calling this function, the caller is responsible for the
│ │ │ │  memory previously managed by the Vec. The only way to do
│ │ │ │  this is to convert the raw pointer, length, and capacity back
│ │ │ │  into a Vec with the from_raw_parts_in function, allowing
│ │ │ │ @@ -531,47 +531,47 @@
│ │ │ │      // We can now make changes to the components, such as
│ │ │ │      // transmuting the raw pointer to a compatible type.
│ │ │ │      let ptr = ptr as *mut u32;
│ │ │ │  
│ │ │ │      Vec::from_raw_parts_in(ptr, len, cap, alloc)
│ │ │ │  };
│ │ │ │  assert_eq!(rebuilt, [4294967295, 0, 1]);Run
      
│ │ │ │ -
      source
      pub fn capacity(&self) -> usize
      Returns the total number of elements the vector can hold without
│ │ │ │ +
      source
      pub fn capacity(&self) -> usize
      Returns the total number of elements the vector can hold without
│ │ │ │  reallocating.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec: Vec<i32> = Vec::with_capacity(10);
│ │ │ │  vec.push(42);
│ │ │ │  assert!(vec.capacity() >= 10);
      Run
      
│ │ │ │ -
      source
      pub fn reserve(&mut self, additional: usize)
      Reserves capacity for at least additional more elements to be inserted
│ │ │ │ +
      source
      pub fn reserve(&mut self, additional: usize)
      Reserves capacity for at least additional more elements to be inserted
│ │ │ │  in the given Vec<T>. The collection may reserve more space to
│ │ │ │  speculatively avoid frequent reallocations. After calling reserve,
│ │ │ │  capacity will be greater than or equal to self.len() + additional.
│ │ │ │  Does nothing if capacity is already sufficient.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if the new capacity exceeds isize::MAX bytes.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![1];
│ │ │ │  vec.reserve(10);
│ │ │ │  assert!(vec.capacity() >= 11);
      Run
      
│ │ │ │ -
      source
      pub fn reserve_exact(&mut self, additional: usize)
      Reserves the minimum capacity for at least additional more elements to
│ │ │ │ +
      source
      pub fn reserve_exact(&mut self, additional: usize)
      Reserves the minimum capacity for at least additional more elements to
│ │ │ │  be inserted in the given Vec<T>. Unlike reserve, this will not
│ │ │ │  deliberately over-allocate to speculatively avoid frequent allocations.
│ │ │ │  After calling reserve_exact, capacity will be greater than or equal to
│ │ │ │  self.len() + additional. Does nothing if the capacity is already
│ │ │ │  sufficient.
      
│ │ │ │  
      Note that the allocator may give the collection more space than it
│ │ │ │  requests. Therefore, capacity can not be relied upon to be precisely
│ │ │ │  minimal. Prefer reserve if future insertions are expected.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if the new capacity exceeds isize::MAX bytes.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![1];
│ │ │ │  vec.reserve_exact(10);
│ │ │ │  assert!(vec.capacity() >= 11);
      Run
      
│ │ │ │ -
      1.57.0 · source
      pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
      Tries to reserve capacity for at least additional more elements to be inserted
│ │ │ │ +
      1.57.0 · source
      pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
      Tries to reserve capacity for at least additional more elements to be inserted
│ │ │ │  in the given Vec<T>. The collection may reserve more space to speculatively avoid
│ │ │ │  frequent reallocations. After calling try_reserve, capacity will be
│ │ │ │  greater than or equal to self.len() + additional if it returns
│ │ │ │  Ok(()). Does nothing if capacity is already sufficient. This method
│ │ │ │  preserves the contents even if an error occurs.
      
│ │ │ │  
      §Errors
      
│ │ │ │  
      If the capacity overflows, or the allocator reports a failure, then an error
│ │ │ │ @@ -590,16 +590,16 @@
│ │ │ │          val * 2 + 5 // very complicated
│ │ │ │      }));
│ │ │ │  
│ │ │ │      Ok(output)
│ │ │ │  }Run
      
│ │ │ │  
      1.57.0 · source
      pub fn try_reserve_exact(
│ │ │ │      &mut self,
│ │ │ │ -    additional: usize
│ │ │ │ -) -> Result<(), TryReserveError>
      Tries to reserve the minimum capacity for at least additional
│ │ │ │ +    additional: usize
│ │ │ │ +) -> Result<(), TryReserveError>
      Tries to reserve the minimum capacity for at least additional
│ │ │ │  elements to be inserted in the given Vec<T>. Unlike try_reserve,
│ │ │ │  this will not deliberately over-allocate to speculatively avoid frequent
│ │ │ │  allocations. After calling try_reserve_exact, capacity will be greater
│ │ │ │  than or equal to self.len() + additional if it returns Ok(()).
│ │ │ │  Does nothing if the capacity is already sufficient.
      
│ │ │ │  
      Note that the allocator may give the collection more space than it
│ │ │ │  requests. Therefore, capacity can not be relied upon to be precisely
│ │ │ │ @@ -629,41 +629,41 @@
│ │ │ │  is the case for with_capacity. See Allocator::shrink for more details.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = Vec::with_capacity(10);
│ │ │ │  vec.extend([1, 2, 3]);
│ │ │ │  assert!(vec.capacity() >= 10);
│ │ │ │  vec.shrink_to_fit();
│ │ │ │  assert!(vec.capacity() >= 3);
      Run
      
│ │ │ │ -
      1.56.0 · source
      pub fn shrink_to(&mut self, min_capacity: usize)
      Shrinks the capacity of the vector with a lower bound.
      
│ │ │ │ +
      1.56.0 · source
      pub fn shrink_to(&mut self, min_capacity: usize)
      Shrinks the capacity of the vector with a lower bound.
      
│ │ │ │  
      The capacity will remain at least as large as both the length
│ │ │ │  and the supplied value.
      
│ │ │ │  
      If the current capacity is less than the lower limit, this is a no-op.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = Vec::with_capacity(10);
│ │ │ │  vec.extend([1, 2, 3]);
│ │ │ │  assert!(vec.capacity() >= 10);
│ │ │ │  vec.shrink_to(4);
│ │ │ │  assert!(vec.capacity() >= 4);
│ │ │ │  vec.shrink_to(0);
│ │ │ │  assert!(vec.capacity() >= 3);
      Run
      
│ │ │ │ -
      source
      pub fn into_boxed_slice(self) -> Box<[T], A>
      Converts the vector into Box<[T]>.
      
│ │ │ │ +
      source
      pub fn into_boxed_slice(self) -> Box<[T], A>
      Converts the vector into Box<[T]>.
      
│ │ │ │  
      Before doing the conversion, this method discards excess capacity like shrink_to_fit.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = vec![1, 2, 3];
│ │ │ │  
│ │ │ │  let slice = v.into_boxed_slice();
      Run
      
│ │ │ │  
      Any excess capacity is removed:
      
│ │ │ │  
│ │ │ │  
      let mut vec = Vec::with_capacity(10);
│ │ │ │  vec.extend([1, 2, 3]);
│ │ │ │  
│ │ │ │  assert!(vec.capacity() >= 10);
│ │ │ │  let slice = vec.into_boxed_slice();
│ │ │ │  assert_eq!(slice.into_vec().capacity(), 3);
      Run
      
│ │ │ │ -
      source
      pub fn truncate(&mut self, len: usize)
      Shortens the vector, keeping the first len elements and dropping
│ │ │ │ +
      source
      pub fn truncate(&mut self, len: usize)
      Shortens the vector, keeping the first len elements and dropping
│ │ │ │  the rest.
      
│ │ │ │  
      If len is greater or equal to the vector’s current length, this has
│ │ │ │  no effect.
      
│ │ │ │  
      The drain method can emulate truncate, but causes the excess
│ │ │ │  elements to be returned instead of dropped.
      
│ │ │ │  
      Note that this method has no effect on the allocated capacity
│ │ │ │  of the vector.
      
│ │ │ │ @@ -681,27 +681,27 @@
│ │ │ │  assert_eq!(vec, [1, 2, 3]);Run
      
│ │ │ │  
      Truncating when len == 0 is equivalent to calling the clear
│ │ │ │  method.
      
│ │ │ │  
│ │ │ │  
      let mut vec = vec![1, 2, 3];
│ │ │ │  vec.truncate(0);
│ │ │ │  assert_eq!(vec, []);
      Run
      
│ │ │ │ -
      1.7.0 · source
      pub fn as_slice(&self) -> &[T]
      Extracts a slice containing the entire vector.
      
│ │ │ │ +
      1.7.0 · source
      pub fn as_slice(&self) -> &[T]
      Extracts a slice containing the entire vector.
      
│ │ │ │  
      Equivalent to &s[..].
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      use std::io::{self, Write};
│ │ │ │  let buffer = vec![1, 2, 3, 5, 8];
│ │ │ │  io::sink().write(buffer.as_slice()).unwrap();
      Run
      
│ │ │ │ -
      1.7.0 · source
      pub fn as_mut_slice(&mut self) -> &mut [T]
      Extracts a mutable slice of the entire vector.
      
│ │ │ │ +
      1.7.0 · source
      pub fn as_mut_slice(&mut self) -> &mut [T]
      Extracts a mutable slice of the entire vector.
      
│ │ │ │  
      Equivalent to &mut s[..].
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      use std::io::{self, Read};
│ │ │ │  let mut buffer = vec![0; 3];
│ │ │ │  io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();
      Run
      
│ │ │ │ -
      1.37.0 · source
      pub fn as_ptr(&self) -> *const T
      Returns a raw pointer to the vector’s buffer, or a dangling raw pointer
│ │ │ │ +
      1.37.0 · source
      pub fn as_ptr(&self) -> *const T
      Returns a raw pointer to the vector’s buffer, or a dangling raw pointer
│ │ │ │  valid for zero sized reads if the vector didn’t allocate.
      
│ │ │ │  
      The caller must ensure that the vector outlives the pointer this
│ │ │ │  function returns, or else it will end up pointing to garbage.
│ │ │ │  Modifying the vector may cause its buffer to be reallocated,
│ │ │ │  which would also make any pointers to it invalid.
      
│ │ │ │  
      The caller must also ensure that the memory the pointer (non-transitively) points to
│ │ │ │  is never written to (except inside an UnsafeCell) using this pointer or any pointer
│ │ │ │ @@ -730,15 +730,15 @@
│ │ │ │      let _ = ptr1.read();
│ │ │ │      let ptr2 = v.as_mut_ptr().offset(2);
│ │ │ │      ptr2.write(2);
│ │ │ │      // Notably, the write to `ptr2` did *not* invalidate `ptr1`
│ │ │ │      // because it mutated a different element:
│ │ │ │      let _ = ptr1.read();
│ │ │ │  }Run
      
│ │ │ │ -
      1.37.0 · source
      pub fn as_mut_ptr(&mut self) -> *mut T
      Returns an unsafe mutable pointer to the vector’s buffer, or a dangling
│ │ │ │ +
      1.37.0 · source
      pub fn as_mut_ptr(&mut self) -> *mut T
      Returns an unsafe mutable pointer to the vector’s buffer, or a dangling
│ │ │ │  raw pointer valid for zero sized reads if the vector didn’t allocate.
      
│ │ │ │  
      The caller must ensure that the vector outlives the pointer this
│ │ │ │  function returns, or else it will end up pointing to garbage.
│ │ │ │  Modifying the vector may cause its buffer to be reallocated,
│ │ │ │  which would also make any pointers to it invalid.
      
│ │ │ │  
      This method guarantees that for the purpose of the aliasing model, this method
│ │ │ │  does not materialize a reference to the underlying slice, and thus the returned pointer
│ │ │ │ @@ -768,20 +768,20 @@
│ │ │ │      let ptr1 = v.as_mut_ptr();
│ │ │ │      ptr1.write(1);
│ │ │ │      let ptr2 = v.as_mut_ptr();
│ │ │ │      ptr2.write(2);
│ │ │ │      // Notably, the write to `ptr2` did *not* invalidate `ptr1`:
│ │ │ │      ptr1.write(3);
│ │ │ │  }Run
      
│ │ │ │ -
      source
      pub fn allocator(&self) -> &A
      🔬This is a nightly-only experimental API. (allocator_api #32838)
      Returns a reference to the underlying allocator.
      
│ │ │ │ -
      source
      pub unsafe fn set_len(&mut self, new_len: usize)
      Forces the length of the vector to new_len.
      
│ │ │ │ +
      source
      pub fn allocator(&self) -> &A
      🔬This is a nightly-only experimental API. (allocator_api #32838)
      Returns a reference to the underlying allocator.
      
│ │ │ │ +
      source
      pub unsafe fn set_len(&mut self, new_len: usize)
      Forces the length of the vector to new_len.
      
│ │ │ │  
      This is a low-level operation that maintains none of the normal
│ │ │ │  invariants of the type. Normally changing the length of a vector
│ │ │ │  is done using one of the safe operations instead, such as
│ │ │ │ -truncate, resize, extend, or clear.
      
│ │ │ │ +truncate, resize, extend, or clear.
      
│ │ │ │  
      §Safety
      
│ │ │ │  
        
│ │ │ │  
      • new_len must be less than or equal to capacity().
        • 
│ │ │ │  
      • The elements at old_len..new_len must be initialized.
        • 
│ │ │ │  
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      This method can be useful for situations in which the vector
│ │ │ │ @@ -817,57 +817,57 @@
│ │ │ │  // 1. `old_len..0` is empty so no elements need to be initialized.
│ │ │ │  // 2. `0 <= capacity` always holds whatever `capacity` is.
│ │ │ │  unsafe {
│ │ │ │      vec.set_len(0);
│ │ │ │  }Run
      
│ │ │ │  
      Normally, here, one would use clear instead to correctly drop
│ │ │ │  the contents and thus not leak memory.
      
│ │ │ │ -
      source
      pub fn swap_remove(&mut self, index: usize) -> T
      Removes an element from the vector and returns it.
      
│ │ │ │ +
      source
      pub fn swap_remove(&mut self, index: usize) -> T
      Removes an element from the vector and returns it.
      
│ │ │ │  
      The removed element is replaced by the last element of the vector.
      
│ │ │ │  
      This does not preserve ordering, but is O(1).
│ │ │ │  If you need to preserve the element order, use remove instead.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if index is out of bounds.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = vec!["foo", "bar", "baz", "qux"];
│ │ │ │  
│ │ │ │  assert_eq!(v.swap_remove(1), "bar");
│ │ │ │  assert_eq!(v, ["foo", "qux", "baz"]);
│ │ │ │  
│ │ │ │  assert_eq!(v.swap_remove(0), "foo");
│ │ │ │  assert_eq!(v, ["baz", "qux"]);
      Run
      
│ │ │ │ -
      source
      pub fn insert(&mut self, index: usize, element: T)
      Inserts an element at position index within the vector, shifting all
│ │ │ │ +
      source
      pub fn insert(&mut self, index: usize, element: T)
      Inserts an element at position index within the vector, shifting all
│ │ │ │  elements after it to the right.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if index > len.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![1, 2, 3];
│ │ │ │  vec.insert(1, 4);
│ │ │ │  assert_eq!(vec, [1, 4, 2, 3]);
│ │ │ │  vec.insert(4, 5);
│ │ │ │  assert_eq!(vec, [1, 4, 2, 3, 5]);
      Run
      
│ │ │ │  
      §Time complexity
      
│ │ │ │  
      Takes O(Vec::len) time. All items after the insertion index must be
│ │ │ │  shifted to the right. In the worst case, all elements are shifted when
│ │ │ │  the insertion index is 0.
      
│ │ │ │ -
      source
      pub fn remove(&mut self, index: usize) -> T
      Removes and returns the element at position index within the vector,
│ │ │ │ +
      source
      pub fn remove(&mut self, index: usize) -> T
      Removes and returns the element at position index within the vector,
│ │ │ │  shifting all elements after it to the left.
      
│ │ │ │  
      Note: Because this shifts over the remaining elements, it has a
│ │ │ │  worst-case performance of O(n). If you don’t need the order of elements
│ │ │ │  to be preserved, use swap_remove instead. If you’d like to remove
│ │ │ │  elements from the beginning of the Vec, consider using
│ │ │ │  VecDeque::pop_front instead.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if index is out of bounds.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = vec![1, 2, 3];
│ │ │ │  assert_eq!(v.remove(1), 2);
│ │ │ │  assert_eq!(v, [1, 3]);
      Run
      
│ │ │ │  
      source
      pub fn retain<F>(&mut self, f: F)
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      Retains only the elements specified by the predicate.
      
│ │ │ │ +    F: FnMut(&T) -> bool,
      Retains only the elements specified by the predicate.
      
│ │ │ │  
      In other words, remove all elements e for which f(&e) returns false.
│ │ │ │  This method operates in place, visiting each element exactly once in the
│ │ │ │  original order, and preserves the order of the retained elements.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![1, 2, 3, 4];
│ │ │ │  vec.retain(|&x| x % 2 == 0);
│ │ │ │  assert_eq!(vec, [2, 4]);
      Run
      
│ │ │ │ @@ -876,40 +876,40 @@
│ │ │ │  
│ │ │ │  
      let mut vec = vec![1, 2, 3, 4, 5];
│ │ │ │  let keep = [false, true, true, false, true];
│ │ │ │  let mut iter = keep.iter();
│ │ │ │  vec.retain(|_| *iter.next().unwrap());
│ │ │ │  assert_eq!(vec, [2, 3, 5]);
      Run
      
│ │ │ │  
      1.61.0 · source
      pub fn retain_mut<F>(&mut self, f: F)
      where
│ │ │ │ -    F: FnMut(&mut T) -> bool,
      Retains only the elements specified by the predicate, passing a mutable reference to it.
      
│ │ │ │ +    F: FnMut(&mut T) -> bool,
      Retains only the elements specified by the predicate, passing a mutable reference to it.
      
│ │ │ │  
      In other words, remove all elements e such that f(&mut e) returns false.
│ │ │ │  This method operates in place, visiting each element exactly once in the
│ │ │ │  original order, and preserves the order of the retained elements.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![1, 2, 3, 4];
│ │ │ │  vec.retain_mut(|x| if *x <= 3 {
│ │ │ │      *x += 1;
│ │ │ │      true
│ │ │ │  } else {
│ │ │ │      false
│ │ │ │  });
│ │ │ │  assert_eq!(vec, [2, 3, 4]);
      Run
      
│ │ │ │  
      1.16.0 · source
      pub fn dedup_by_key<F, K>(&mut self, key: F)
      where
│ │ │ │ -    F: FnMut(&mut T) -> K,
│ │ │ │ -    K: PartialEq,
      Removes all but the first of consecutive elements in the vector that resolve to the same
│ │ │ │ +    F: FnMut(&mut T) -> K,
│ │ │ │ +    K: PartialEq,
      Removes all but the first of consecutive elements in the vector that resolve to the same
│ │ │ │  key.
      
│ │ │ │  
      If the vector is sorted, this removes all duplicates.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![10, 20, 21, 30, 20];
│ │ │ │  
│ │ │ │  vec.dedup_by_key(|i| *i / 10);
│ │ │ │  
│ │ │ │  assert_eq!(vec, [10, 20, 30, 20]);
      Run
      
│ │ │ │  
      1.16.0 · source
      pub fn dedup_by<F>(&mut self, same_bucket: F)
      where
│ │ │ │ -    F: FnMut(&mut T, &mut T) -> bool,
      Removes all but the first of consecutive elements in the vector satisfying a given equality
│ │ │ │ +    F: FnMut(&mut T, &mut T) -> bool,
      Removes all but the first of consecutive elements in the vector satisfying a given equality
│ │ │ │  relation.
      
│ │ │ │  
      The same_bucket function is passed references to two elements from the vector and
│ │ │ │  must determine if the elements compare equal. The elements are passed in opposite order
│ │ │ │  from their order in the slice, so if same_bucket(a, b) returns true, a is removed.
      
│ │ │ │  
      If the vector is sorted, this removes all duplicates.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
│ │ │ │ @@ -925,20 +925,20 @@
│ │ │ │  vec.push(3);
│ │ │ │  assert_eq!(vec, [1, 2, 3]);
      Run
      
│ │ │ │  
      §Time complexity
      
│ │ │ │  
      Takes amortized O(1) time. If the vector’s length would exceed its
│ │ │ │  capacity after the push, O(capacity) time is taken to copy the
│ │ │ │  vector’s elements to a larger allocation. This expensive operation is
│ │ │ │  offset by the capacity O(1) insertions it allows.
      
│ │ │ │ -
      source
      pub fn push_within_capacity(&mut self, value: T) -> Result<(), T>
      🔬This is a nightly-only experimental API. (vec_push_within_capacity #100486)
      Appends an element if there is sufficient spare capacity, otherwise an error is returned
│ │ │ │ +
      source
      pub fn push_within_capacity(&mut self, value: T) -> Result<(), T>
      🔬This is a nightly-only experimental API. (vec_push_within_capacity #100486)
      Appends an element if there is sufficient spare capacity, otherwise an error is returned
│ │ │ │  with the element.
      
│ │ │ │  
      Unlike push this method will not reallocate when there’s insufficient capacity.
│ │ │ │  The caller should use reserve or try_reserve to ensure that there is enough capacity.
      
│ │ │ │  
      §Examples
      
│ │ │ │ -
      A manual, panic-free alternative to FromIterator:
      
│ │ │ │ +
      A manual, panic-free alternative to FromIterator:
      
│ │ │ │  
│ │ │ │  
      #![feature(vec_push_within_capacity)]
│ │ │ │  
│ │ │ │  use std::collections::TryReserveError;
│ │ │ │  fn from_iter_fallible<T>(iter: impl Iterator<Item=T>) -> Result<Vec<T>, TryReserveError> {
│ │ │ │      let mut vec = Vec::new();
│ │ │ │      for value in iter {
│ │ │ │ @@ -949,45 +949,45 @@
│ │ │ │          }
│ │ │ │      }
│ │ │ │      Ok(vec)
│ │ │ │  }
│ │ │ │  assert_eq!(from_iter_fallible(0..100), Ok(Vec::from_iter(0..100)));
      Run
      
│ │ │ │  
      §Time complexity
      
│ │ │ │  
      Takes O(1) time.
      
│ │ │ │ -
      source
      pub fn pop(&mut self) -> Option<T>
      Removes the last element from a vector and returns it, or None if it
│ │ │ │ +
      source
      pub fn pop(&mut self) -> Option<T>
      Removes the last element from a vector and returns it, or None if it
│ │ │ │  is empty.
      
│ │ │ │  
      If you’d like to pop the first element, consider using
│ │ │ │  VecDeque::pop_front instead.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![1, 2, 3];
│ │ │ │  assert_eq!(vec.pop(), Some(3));
│ │ │ │  assert_eq!(vec, [1, 2]);
      Run
      
│ │ │ │  
      §Time complexity
      
│ │ │ │  
      Takes O(1) time.
      
│ │ │ │ -
      1.4.0 · source
      pub fn append(&mut self, other: &mut Self)
      Moves all the elements of other into self, leaving other empty.
      
│ │ │ │ +
      1.4.0 · source
      pub fn append(&mut self, other: &mut Self)
      Moves all the elements of other into self, leaving other empty.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if the new capacity exceeds isize::MAX bytes.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![1, 2, 3];
│ │ │ │  let mut vec2 = vec![4, 5, 6];
│ │ │ │  vec.append(&mut vec2);
│ │ │ │  assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
│ │ │ │  assert_eq!(vec2, []);
      Run
      
│ │ │ │  
      1.6.0 · source
      pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A> ⓘ
      where
│ │ │ │ -    R: RangeBounds<usize>,
      Removes the specified range from the vector in bulk, returning all
│ │ │ │ +    R: RangeBounds<usize>,
      Removes the specified range from the vector in bulk, returning all
│ │ │ │  removed elements as an iterator. If the iterator is dropped before
│ │ │ │  being fully consumed, it drops the remaining removed elements.
      
│ │ │ │  
      The returned iterator keeps a mutable borrow on the vector to optimize
│ │ │ │  its implementation.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if the starting point is greater than the end point or if
│ │ │ │  the end point is greater than the length of the vector.
      
│ │ │ │  
      §Leaking
      
│ │ │ │  
      If the returned iterator goes out of scope without being dropped (due to
│ │ │ │ -mem::forget, for example), the vector may have lost and leaked
│ │ │ │ +mem::forget, for example), the vector may have lost and leaked
│ │ │ │  elements arbitrarily, including elements outside the range.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = vec![1, 2, 3];
│ │ │ │  let u: Vec<_> = v.drain(1..).collect();
│ │ │ │  assert_eq!(v, &[1]);
│ │ │ │  assert_eq!(u, &[2, 3]);
│ │ │ │  
│ │ │ │ @@ -999,66 +999,66 @@
│ │ │ │  of the vector.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = vec![1, 2, 3];
│ │ │ │  
│ │ │ │  v.clear();
│ │ │ │  
│ │ │ │  assert!(v.is_empty());
      Run
      
│ │ │ │ -
      source
      pub fn len(&self) -> usize
      Returns the number of elements in the vector, also referred to
│ │ │ │ +
      source
      pub fn len(&self) -> usize
      Returns the number of elements in the vector, also referred to
│ │ │ │  as its ‘length’.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let a = vec![1, 2, 3];
│ │ │ │  assert_eq!(a.len(), 3);
      Run
      
│ │ │ │ -
      source
      pub fn is_empty(&self) -> bool
      Returns true if the vector contains no elements.
      
│ │ │ │ +
      source
      pub fn is_empty(&self) -> bool
      Returns true if the vector contains no elements.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = Vec::new();
│ │ │ │  assert!(v.is_empty());
│ │ │ │  
│ │ │ │  v.push(1);
│ │ │ │  assert!(!v.is_empty());
      Run
      
│ │ │ │ -
      1.4.0 · source
      pub fn split_off(&mut self, at: usize) -> Self
      where
│ │ │ │ -    A: Clone,
      Splits the collection into two at the given index.
      
│ │ │ │ +
      1.4.0 · source
      pub fn split_off(&mut self, at: usize) -> Self
      where
│ │ │ │ +    A: Clone,
      Splits the collection into two at the given index.
      
│ │ │ │  
      Returns a newly allocated vector containing the elements in the range
│ │ │ │  [at, len). After the call, the original vector will be left containing
│ │ │ │  the elements [0, at) with its previous capacity unchanged.
      
│ │ │ │  
        
│ │ │ │  
      • If you want to take ownership of the entire contents and capacity of
│ │ │ │ -the vector, see mem::take or mem::replace.
        • 
│ │ │ │ +the vector, see mem::take or mem::replace.
│ │ │ │  
      • If you don’t need the returned vector at all, see Vec::truncate.
        • 
│ │ │ │  
      • If you want to take ownership of an arbitrary subslice, or you don’t
│ │ │ │  necessarily want to store the removed items in a vector, see Vec::drain.
        • 
│ │ │ │  
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if at > len.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![1, 2, 3];
│ │ │ │  let vec2 = vec.split_off(1);
│ │ │ │  assert_eq!(vec, [1]);
│ │ │ │  assert_eq!(vec2, [2, 3]);
      Run
      
│ │ │ │ -
      1.33.0 · source
      pub fn resize_with<F>(&mut self, new_len: usize, f: F)
      where
│ │ │ │ -    F: FnMut() -> T,
      Resizes the Vec in-place so that len is equal to new_len.
      
│ │ │ │ +
      1.33.0 · source
      pub fn resize_with<F>(&mut self, new_len: usize, f: F)
      where
│ │ │ │ +    F: FnMut() -> T,
      Resizes the Vec in-place so that len is equal to new_len.
      
│ │ │ │  
      If new_len is greater than len, the Vec is extended by the
│ │ │ │  difference, with each additional slot filled with the result of
│ │ │ │  calling the closure f. The return values from f will end up
│ │ │ │  in the Vec in the order they have been generated.
      
│ │ │ │  
      If new_len is less than len, the Vec is simply truncated.
      
│ │ │ │  
      This method uses a closure to create new values on every push. If
│ │ │ │ -you’d rather Clone a given value, use Vec::resize. If you
│ │ │ │ -want to use the Default trait to generate values, you can
│ │ │ │ -pass Default::default as the second argument.
      
│ │ │ │ +you’d rather Clone a given value, use Vec::resize. If you
│ │ │ │ +want to use the Default trait to generate values, you can
│ │ │ │ +pass Default::default as the second argument.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![1, 2, 3];
│ │ │ │  vec.resize_with(5, Default::default);
│ │ │ │  assert_eq!(vec, [1, 2, 3, 0, 0]);
│ │ │ │  
│ │ │ │  let mut vec = vec![];
│ │ │ │  let mut p = 1;
│ │ │ │  vec.resize_with(4, || { p *= 2; p });
│ │ │ │  assert_eq!(vec, [2, 4, 8, 16]);
      Run
      
│ │ │ │ -
      1.47.0 · source
      pub fn leak<'a>(self) -> &'a mut [T]
      where
│ │ │ │ +
      1.47.0 · source
      pub fn leak<'a>(self) -> &'a mut [T]
      where
│ │ │ │      A: 'a,
      Consumes and leaks the Vec, returning a mutable reference to the contents,
│ │ │ │  &'a mut [T]. Note that the type T must outlive the chosen lifetime
│ │ │ │  'a. If the type has only static references, or none at all, then this
│ │ │ │  may be chosen to be 'static.
      
│ │ │ │  
      As of Rust 1.57, this method does not reallocate or shrink the Vec,
│ │ │ │  so the leaked allocation may include unused capacity that is not part
│ │ │ │  of the returned slice.
      
│ │ │ │ @@ -1068,15 +1068,15 @@
│ │ │ │  
      §Examples
      
│ │ │ │  
      Simple usage:
      
│ │ │ │  
│ │ │ │  
      let x = vec![1, 2, 3];
│ │ │ │  let static_ref: &'static mut [usize] = x.leak();
│ │ │ │  static_ref[0] += 1;
│ │ │ │  assert_eq!(static_ref, &[2, 2, 3]);
      Run
      
│ │ │ │ -
      1.60.0 · source
      pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>]
      Returns the remaining spare capacity of the vector as a slice of
│ │ │ │ +
      1.60.0 · source
      pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>]
      Returns the remaining spare capacity of the vector as a slice of
│ │ │ │  MaybeUninit<T>.
      
│ │ │ │  
      The returned slice can be used to fill the vector with data (e.g. by
│ │ │ │  reading from a file) before marking the data as initialized using the
│ │ │ │  set_len method.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      // Allocate vector big enough for 10 elements.
│ │ │ │  let mut v = Vec::with_capacity(10);
│ │ │ │ @@ -1089,15 +1089,15 @@
│ │ │ │  
│ │ │ │  // Mark the first 3 elements of the vector as being initialized.
│ │ │ │  unsafe {
│ │ │ │      v.set_len(3);
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(&v, &[0, 1, 2]);
      Run
      
│ │ │ │ -
      source
      pub fn split_at_spare_mut(&mut self) -> (&mut [T], &mut [MaybeUninit<T>])
      🔬This is a nightly-only experimental API. (vec_split_at_spare #81944)
      Returns vector content as a slice of T, along with the remaining spare
│ │ │ │ +
      source
      pub fn split_at_spare_mut(&mut self) -> (&mut [T], &mut [MaybeUninit<T>])
      🔬This is a nightly-only experimental API. (vec_split_at_spare #81944)
      Returns vector content as a slice of T, along with the remaining spare
│ │ │ │  capacity of the vector as a slice of MaybeUninit<T>.
      
│ │ │ │  
      The returned spare capacity slice can be used to fill the vector with data
│ │ │ │  (e.g. by reading from a file) before marking the data as initialized using
│ │ │ │  the set_len method.
      
│ │ │ │  
      Note that this is a low-level API, which should be used with care for
│ │ │ │  optimization purposes. If you need to append data to a Vec
│ │ │ │  you can use push, extend, extend_from_slice,
│ │ │ │ @@ -1123,88 +1123,88 @@
│ │ │ │  // Mark the 4 elements of the vector as being initialized.
│ │ │ │  unsafe {
│ │ │ │      let len = v.len();
│ │ │ │      v.set_len(len + 4);
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(&v, &[1, 1, 2, 4, 8, 12, 16]);Run
      
│ │ │ │ -
      source§
      impl<T: Clone, A: Allocator> Vec<T, A>
      1.5.0 · source
      pub fn resize(&mut self, new_len: usize, value: T)
      Resizes the Vec in-place so that len is equal to new_len.
      
│ │ │ │ +
      source§
      impl<T: Clone, A: Allocator> Vec<T, A>
      1.5.0 · source
      pub fn resize(&mut self, new_len: usize, value: T)
      Resizes the Vec in-place so that len is equal to new_len.
      
│ │ │ │  
      If new_len is greater than len, the Vec is extended by the
│ │ │ │  difference, with each additional slot filled with value.
│ │ │ │  If new_len is less than len, the Vec is simply truncated.
      
│ │ │ │ -
      This method requires T to implement Clone,
│ │ │ │ +
      This method requires T to implement Clone,
│ │ │ │  in order to be able to clone the passed value.
│ │ │ │ -If you need more flexibility (or want to rely on Default instead of
│ │ │ │ -Clone), use Vec::resize_with.
│ │ │ │ +If you need more flexibility (or want to rely on Default instead of
│ │ │ │ +Clone), use Vec::resize_with.
│ │ │ │  If you only need to resize to a smaller size, use Vec::truncate.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec!["hello"];
│ │ │ │  vec.resize(3, "world");
│ │ │ │  assert_eq!(vec, ["hello", "world", "world"]);
│ │ │ │  
│ │ │ │  let mut vec = vec![1, 2, 3, 4];
│ │ │ │  vec.resize(2, 0);
│ │ │ │  assert_eq!(vec, [1, 2]);
      Run
      
│ │ │ │ -
      1.6.0 · source
      pub fn extend_from_slice(&mut self, other: &[T])
      Clones and appends all elements in a slice to the Vec.
      
│ │ │ │ +
      1.6.0 · source
      pub fn extend_from_slice(&mut self, other: &[T])
      Clones and appends all elements in a slice to the Vec.
      
│ │ │ │  
      Iterates over the slice other, clones each element, and then appends
│ │ │ │  it to this Vec. The other slice is traversed in-order.
      
│ │ │ │  
      Note that this function is same as extend except that it is
│ │ │ │  specialized to work with slices instead. If and when Rust gets
│ │ │ │  specialization this function will likely be deprecated (but still
│ │ │ │  available).
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![1];
│ │ │ │  vec.extend_from_slice(&[2, 3, 4]);
│ │ │ │  assert_eq!(vec, [1, 2, 3, 4]);
      Run
      
│ │ │ │  
      1.53.0 · source
      pub fn extend_from_within<R>(&mut self, src: R)
      where
│ │ │ │ -    R: RangeBounds<usize>,
      Copies elements from src range to the end of the vector.
      
│ │ │ │ +    R: RangeBounds<usize>,
      Copies elements from src range to the end of the vector.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if the starting point is greater than the end point or if
│ │ │ │  the end point is greater than the length of the vector.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![0, 1, 2, 3, 4];
│ │ │ │  
│ │ │ │  vec.extend_from_within(2..);
│ │ │ │  assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4]);
│ │ │ │  
│ │ │ │  vec.extend_from_within(..2);
│ │ │ │  assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4, 0, 1]);
│ │ │ │  
│ │ │ │  vec.extend_from_within(4..8);
│ │ │ │  assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4, 0, 1, 4, 2, 3, 4]);
      Run
      
│ │ │ │ -
      source§
      impl<T, A: Allocator, const N: usize> Vec<[T; N], A>
      source
      pub fn into_flattened(self) -> Vec<T, A>
      🔬This is a nightly-only experimental API. (slice_flatten #95629)
      Takes a Vec<[T; N]> and flattens it into a Vec<T>.
      
│ │ │ │ +
      source§
      impl<T, A: Allocator, const N: usize> Vec<[T; N], A>
      source
      pub fn into_flattened(self) -> Vec<T, A>
      🔬This is a nightly-only experimental API. (slice_flatten #95629)
      Takes a Vec<[T; N]> and flattens it into a Vec<T>.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if the length of the resulting vector would overflow a usize.
      
│ │ │ │  
      This is only possible when flattening a vector of arrays of zero-sized
│ │ │ │  types, and thus tends to be irrelevant in practice. If
│ │ │ │  size_of::<T>() > 0, this will never panic.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_flatten)]
│ │ │ │  
│ │ │ │  let mut vec = vec![[1, 2, 3], [4, 5, 6], [7, 8, 9]];
│ │ │ │  assert_eq!(vec.pop(), Some([7, 8, 9]));
│ │ │ │  
│ │ │ │  let mut flattened = vec.into_flattened();
│ │ │ │  assert_eq!(flattened.pop(), Some(6));
      Run
      
│ │ │ │ -
      source§
      impl<T: PartialEq, A: Allocator> Vec<T, A>
      source
      pub fn dedup(&mut self)
      Removes consecutive repeated elements in the vector according to the
│ │ │ │ -PartialEq trait implementation.
      
│ │ │ │ +
      source§
      impl<T: PartialEq, A: Allocator> Vec<T, A>
      source
      pub fn dedup(&mut self)
      Removes consecutive repeated elements in the vector according to the
│ │ │ │ +PartialEq trait implementation.
      
│ │ │ │  
      If the vector is sorted, this removes all duplicates.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut vec = vec![1, 2, 2, 3, 2];
│ │ │ │  
│ │ │ │  vec.dedup();
│ │ │ │  
│ │ │ │  assert_eq!(vec, [1, 2, 3, 2]);
      Run
      
│ │ │ │  
      source§
      impl<T, A: Allocator> Vec<T, A>
      1.21.0 · source
      pub fn splice<R, I>(
│ │ │ │      &mut self,
│ │ │ │      range: R,
│ │ │ │      replace_with: I
│ │ │ │ -) -> Splice<'_, I::IntoIter, A> ⓘ
      where
│ │ │ │ -    R: RangeBounds<usize>,
│ │ │ │ -    I: IntoIterator<Item = T>,
      Creates a splicing iterator that replaces the specified range in the vector
│ │ │ │ +) -> Splice<'_, I::IntoIter, A> ⓘ
      where
│ │ │ │ +    R: RangeBounds<usize>,
│ │ │ │ +    I: IntoIterator<Item = T>,
      Creates a splicing iterator that replaces the specified range in the vector
│ │ │ │  with the given replace_with iterator and yields the removed items.
│ │ │ │  replace_with does not need to be the same length as range.
      
│ │ │ │  
      range is removed even if the iterator is not consumed until the end.
      
│ │ │ │  
      It is unspecified how many elements are removed from the vector
│ │ │ │  if the Splice value is leaked.
      
│ │ │ │  
      The input iterator replace_with is only consumed when the Splice value is dropped.
      
│ │ │ │  
      This is optimal if:
      
│ │ │ │ @@ -1220,15 +1220,15 @@
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = vec![1, 2, 3, 4];
│ │ │ │  let new = [7, 8, 9];
│ │ │ │  let u: Vec<_> = v.splice(1..3, new).collect();
│ │ │ │  assert_eq!(v, &[1, 7, 8, 9, 4]);
│ │ │ │  assert_eq!(u, &[2, 3]);
      Run
      
│ │ │ │  
      source
      pub fn extract_if<F>(&mut self, filter: F) -> ExtractIf<'_, T, F, A> ⓘ
      where
│ │ │ │ -    F: FnMut(&mut T) -> bool,
      🔬This is a nightly-only experimental API. (extract_if #43244)
      Creates an iterator which uses a closure to determine if an element should be removed.
      
│ │ │ │ +    F: FnMut(&mut T) -> bool,
      🔬This is a nightly-only experimental API. (extract_if #43244)
      Creates an iterator which uses a closure to determine if an element should be removed.
      
│ │ │ │  
      If the closure returns true, then the element is removed and yielded.
│ │ │ │  If the closure returns false, the element will remain in the vector and will not be yielded
│ │ │ │  by the iterator.
      
│ │ │ │  
      If the returned ExtractIf is not exhausted, e.g. because it is dropped without iterating
│ │ │ │  or the iteration short-circuits, then the remaining elements will be retained.
│ │ │ │  Use retain with a negated predicate if you do not need the returned iterator.
      
│ │ │ │  
      Using this method is equivalent to the following code:
      
│ │ │ │ @@ -1254,51 +1254,51 @@
│ │ │ │  let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];
│ │ │ │  
│ │ │ │  let evens = numbers.extract_if(|x| *x % 2 == 0).collect::<Vec<_>>();
│ │ │ │  let odds = numbers;
│ │ │ │  
│ │ │ │  assert_eq!(evens, vec![2, 4, 6, 8, 14]);
│ │ │ │  assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);Run
      
│ │ │ │ -
      Methods from Deref<Target = [T]>§
      source
      pub fn sort(&mut self)
      where
│ │ │ │ -    T: Ord,
      Sorts the slice.
      
│ │ │ │ +
      Methods from Deref<Target = [T]>§
      source
      pub fn sort(&mut self)
      where
│ │ │ │ +    T: Ord,
      Sorts the slice.
      
│ │ │ │  
      This sort is stable (i.e., does not reorder equal elements) and O(n * log(n)) worst-case.
      
│ │ │ │  
      When applicable, unstable sorting is preferred because it is generally faster than stable
│ │ │ │  sorting and it doesn’t allocate auxiliary memory.
│ │ │ │ -See sort_unstable.
      
│ │ │ │ +See sort_unstable.
      
│ │ │ │  
      §Current implementation
      
│ │ │ │  
      The current algorithm is an adaptive, iterative merge sort inspired by
│ │ │ │  timsort.
│ │ │ │  It is designed to be very fast in cases where the slice is nearly sorted, or consists of
│ │ │ │  two or more sorted sequences concatenated one after another.
      
│ │ │ │  
      Also, it allocates temporary storage half the size of self, but for short slices a
│ │ │ │  non-allocating insertion sort is used instead.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [-5, 4, 1, -3, 2];
│ │ │ │  
│ │ │ │  v.sort();
│ │ │ │  assert!(v == [-5, -3, 1, 2, 4]);
      Run
      
│ │ │ │  
      source
      pub fn sort_by<F>(&mut self, compare: F)
      where
│ │ │ │ -    F: FnMut(&T, &T) -> Ordering,
      Sorts the slice with a comparator function.
      
│ │ │ │ +    F: FnMut(&T, &T) -> Ordering,
      Sorts the slice with a comparator function.
      
│ │ │ │  
      This sort is stable (i.e., does not reorder equal elements) and O(n * log(n)) worst-case.
      
│ │ │ │  
      The comparator function must define a total ordering for the elements in the slice. If
│ │ │ │  the ordering is not total, the order of the elements is unspecified. An order is a
│ │ │ │  total order if it is (for all a, b and c):
      
│ │ │ │  
        
│ │ │ │  
      • total and antisymmetric: exactly one of a < b, a == b or a > b is true, and
        • 
│ │ │ │  
      • transitive, a < b and b < c implies a < c. The same must hold for both == and >.
        • 
│ │ │ │  
      
│ │ │ │ -
      For example, while f64 doesn’t implement Ord because NaN != NaN, we can use
│ │ │ │ +
      For example, while f64 doesn’t implement Ord because NaN != NaN, we can use
│ │ │ │  partial_cmp as our sort function when we know the slice doesn’t contain a NaN.
      
│ │ │ │  
│ │ │ │  
      let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
│ │ │ │  floats.sort_by(|a, b| a.partial_cmp(b).unwrap());
│ │ │ │  assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
      Run
      
│ │ │ │  
      When applicable, unstable sorting is preferred because it is generally faster than stable
│ │ │ │  sorting and it doesn’t allocate auxiliary memory.
│ │ │ │ -See sort_unstable_by.
      
│ │ │ │ +See sort_unstable_by.
      
│ │ │ │  
      §Current implementation
      
│ │ │ │  
      The current algorithm is an adaptive, iterative merge sort inspired by
│ │ │ │  timsort.
│ │ │ │  It is designed to be very fast in cases where the slice is nearly sorted, or consists of
│ │ │ │  two or more sorted sequences concatenated one after another.
      
│ │ │ │  
      Also, it allocates temporary storage half the size of self, but for short slices a
│ │ │ │  non-allocating insertion sort is used instead.
      
│ │ │ │ @@ -1307,47 +1307,47 @@
│ │ │ │  v.sort_by(|a, b| a.cmp(b));
│ │ │ │  assert!(v == [1, 2, 3, 4, 5]);
│ │ │ │  
│ │ │ │  // reverse sorting
│ │ │ │  v.sort_by(|a, b| b.cmp(a));
│ │ │ │  assert!(v == [5, 4, 3, 2, 1]);Run
      
│ │ │ │  
      1.7.0 · source
      pub fn sort_by_key<K, F>(&mut self, f: F)
      where
│ │ │ │ -    F: FnMut(&T) -> K,
│ │ │ │ -    K: Ord,
      Sorts the slice with a key extraction function.
      
│ │ │ │ +    F: FnMut(&T) -> K,
│ │ │ │ +    K: Ord,
      Sorts the slice with a key extraction function.
      
│ │ │ │  
      This sort is stable (i.e., does not reorder equal elements) and O(m * n * log(n))
│ │ │ │  worst-case, where the key function is O(m).
      
│ │ │ │  
      For expensive key functions (e.g. functions that are not simple property accesses or
│ │ │ │ -basic operations), sort_by_cached_key is likely to be
│ │ │ │ +basic operations), sort_by_cached_key is likely to be
│ │ │ │  significantly faster, as it does not recompute element keys.
      
│ │ │ │  
      When applicable, unstable sorting is preferred because it is generally faster than stable
│ │ │ │  sorting and it doesn’t allocate auxiliary memory.
│ │ │ │ -See sort_unstable_by_key.
      
│ │ │ │ +See sort_unstable_by_key.
      
│ │ │ │  
      §Current implementation
      
│ │ │ │  
      The current algorithm is an adaptive, iterative merge sort inspired by
│ │ │ │  timsort.
│ │ │ │  It is designed to be very fast in cases where the slice is nearly sorted, or consists of
│ │ │ │  two or more sorted sequences concatenated one after another.
      
│ │ │ │  
      Also, it allocates temporary storage half the size of self, but for short slices a
│ │ │ │  non-allocating insertion sort is used instead.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [-5i32, 4, 1, -3, 2];
│ │ │ │  
│ │ │ │  v.sort_by_key(|k| k.abs());
│ │ │ │  assert!(v == [1, 2, -3, 4, -5]);
      Run
      
│ │ │ │  
      1.34.0 · source
      pub fn sort_by_cached_key<K, F>(&mut self, f: F)
      where
│ │ │ │ -    F: FnMut(&T) -> K,
│ │ │ │ -    K: Ord,
      Sorts the slice with a key extraction function.
      
│ │ │ │ +    F: FnMut(&T) -> K,
│ │ │ │ +    K: Ord,
      Sorts the slice with a key extraction function.
      
│ │ │ │  
      During sorting, the key function is called at most once per element, by using
│ │ │ │  temporary storage to remember the results of key evaluation.
│ │ │ │  The order of calls to the key function is unspecified and may change in future versions
│ │ │ │  of the standard library.
      
│ │ │ │  
      This sort is stable (i.e., does not reorder equal elements) and O(m * n + n * log(n))
│ │ │ │  worst-case, where the key function is O(m).
      
│ │ │ │  
      For simple key functions (e.g., functions that are property accesses or
│ │ │ │ -basic operations), sort_by_key is likely to be
│ │ │ │ +basic operations), sort_by_key is likely to be
│ │ │ │  faster.
      
│ │ │ │  
      §Current implementation
      
│ │ │ │  
      The current algorithm is based on pattern-defeating quicksort by Orson Peters,
│ │ │ │  which combines the fast average case of randomized quicksort with the fast worst case of
│ │ │ │  heapsort, while achieving linear time on slices with certain patterns. It uses some
│ │ │ │  randomization to avoid degenerate cases, but with a fixed seed to always provide
│ │ │ │  deterministic behavior.
      
│ │ │ │ @@ -1355,42 +1355,42 @@
│ │ │ │  length of the slice.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [-5i32, 4, 32, -3, 2];
│ │ │ │  
│ │ │ │  v.sort_by_cached_key(|k| k.to_string());
│ │ │ │  assert!(v == [-3, -5, 2, 32, 4]);
      Run
      
│ │ │ │  
      source
      pub fn to_vec(&self) -> Vec<T>
      where
│ │ │ │ -    T: Clone,
      Copies self into a new Vec.
      
│ │ │ │ +    T: Clone,
      Copies self into a new Vec.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let s = [10, 40, 30];
│ │ │ │  let x = s.to_vec();
│ │ │ │  // Here, `s` and `x` can be modified independently.
      Run
      
│ │ │ │  
      source
      pub fn to_vec_in<A: Allocator>(&self, alloc: A) -> Vec<T, A>
      where
│ │ │ │ -    T: Clone,
      🔬This is a nightly-only experimental API. (allocator_api #32838)
      Copies self into a new Vec with an allocator.
      
│ │ │ │ +    T: Clone,
      🔬This is a nightly-only experimental API. (allocator_api #32838)
      Copies self into a new Vec with an allocator.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(allocator_api)]
│ │ │ │  
│ │ │ │  use std::alloc::System;
│ │ │ │  
│ │ │ │  let s = [10, 40, 30];
│ │ │ │  let x = s.to_vec_in(System);
│ │ │ │  // Here, `s` and `x` can be modified independently.
      Run
      
│ │ │ │ -
      1.40.0 · source
      pub fn repeat(&self, n: usize) -> Vec<T>
      where
│ │ │ │ -    T: Copy,
      Creates a vector by copying a slice n times.
      
│ │ │ │ +
      1.40.0 · source
      pub fn repeat(&self, n: usize) -> Vec<T>
      where
│ │ │ │ +    T: Copy,
      Creates a vector by copying a slice n times.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      This function will panic if the capacity would overflow.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      Basic usage:
      
│ │ │ │  
│ │ │ │  
      assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]);
      Run
      
│ │ │ │  
      A panic upon overflow:
      
│ │ │ │  
│ │ │ │  
      ⓘ
      // this will panic at runtime
│ │ │ │  b"0123456789abcdef".repeat(usize::MAX);
      Run
      
│ │ │ │ -
      source
      pub fn concat<Item: ?Sized>(&self) -> <Self as Concat<Item>>::Output
      where
│ │ │ │ +
      source
      pub fn concat<Item: ?Sized>(&self) -> <Self as Concat<Item>>::Output
      where
│ │ │ │      Self: Concat<Item>,
      Flattens a slice of T into a single value Self::Output.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      assert_eq!(["hello", "world"].concat(), "helloworld");
│ │ │ │  assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);
      Run
      
│ │ │ │  
      1.3.0 · source
      pub fn join<Separator>(
│ │ │ │      &self,
│ │ │ │      sep: Separator
│ │ │ │ @@ -1406,40 +1406,40 @@
│ │ │ │      sep: Separator
│ │ │ │  ) -> <Self as Join<Separator>>::Output
      where
│ │ │ │      Self: Join<Separator>,
      👎Deprecated since 1.3.0: renamed to join
      Flattens a slice of T into a single value Self::Output, placing a
│ │ │ │  given separator between each.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      assert_eq!(["hello", "world"].connect(" "), "hello world");
│ │ │ │  assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]);
      Run
      
│ │ │ │ -
      1.23.0 · source
      pub fn to_ascii_uppercase(&self) -> Vec<u8>
      Returns a vector containing a copy of this slice where each byte
│ │ │ │ +
      1.23.0 · source
      pub fn to_ascii_uppercase(&self) -> Vec<u8>
      Returns a vector containing a copy of this slice where each byte
│ │ │ │  is mapped to its ASCII upper case equivalent.
      
│ │ │ │  
      ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’,
│ │ │ │  but non-ASCII letters are unchanged.
      
│ │ │ │ -
      To uppercase the value in-place, use make_ascii_uppercase.
      
│ │ │ │ -
      1.23.0 · source
      pub fn to_ascii_lowercase(&self) -> Vec<u8>
      Returns a vector containing a copy of this slice where each byte
│ │ │ │ +
      To uppercase the value in-place, use make_ascii_uppercase.
      
│ │ │ │ +
      1.23.0 · source
      pub fn to_ascii_lowercase(&self) -> Vec<u8>
      Returns a vector containing a copy of this slice where each byte
│ │ │ │  is mapped to its ASCII lower case equivalent.
      
│ │ │ │  
      ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’,
│ │ │ │  but non-ASCII letters are unchanged.
      
│ │ │ │ -
      To lowercase the value in-place, use make_ascii_lowercase.
      
│ │ │ │ -
      source
      pub fn as_str(&self) -> &str
      🔬This is a nightly-only experimental API. (ascii_char #110998)
      Views this slice of ASCII characters as a UTF-8 str.
      
│ │ │ │ -
      source
      pub fn as_bytes(&self) -> &[u8]
      🔬This is a nightly-only experimental API. (ascii_char #110998)
      Views this slice of ASCII characters as a slice of u8 bytes.
      
│ │ │ │ -
      source
      pub fn sort_floats(&mut self)
      🔬This is a nightly-only experimental API. (sort_floats #93396)
      Sorts the slice of floats.
      
│ │ │ │ +
      To lowercase the value in-place, use make_ascii_lowercase.
      
│ │ │ │ +
      source
      pub fn as_str(&self) -> &str
      🔬This is a nightly-only experimental API. (ascii_char #110998)
      Views this slice of ASCII characters as a UTF-8 str.
      
│ │ │ │ +
      source
      pub fn as_bytes(&self) -> &[u8]
      🔬This is a nightly-only experimental API. (ascii_char #110998)
      Views this slice of ASCII characters as a slice of u8 bytes.
      
│ │ │ │ +
      source
      pub fn sort_floats(&mut self)
      🔬This is a nightly-only experimental API. (sort_floats #93396)
      Sorts the slice of floats.
      
│ │ │ │  
      This sort is in-place (i.e. does not allocate), O(n * log(n)) worst-case, and uses
│ │ │ │ -the ordering defined by f32::total_cmp.
      
│ │ │ │ +the ordering defined by f32::total_cmp.
      
│ │ │ │  
      §Current implementation
      
│ │ │ │ -
      This uses the same sorting algorithm as sort_unstable_by.
      
│ │ │ │ +
      This uses the same sorting algorithm as sort_unstable_by.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(sort_floats)]
│ │ │ │  let mut v = [2.6, -5e-8, f32::NAN, 8.29, f32::INFINITY, -1.0, 0.0, -f32::INFINITY, -0.0];
│ │ │ │  
│ │ │ │  v.sort_floats();
│ │ │ │  let sorted = [-f32::INFINITY, -1.0, -5e-8, -0.0, 0.0, 2.6, 8.29, f32::INFINITY, f32::NAN];
│ │ │ │  assert_eq!(&v[..8], &sorted[..8]);
│ │ │ │  assert!(v[8].is_nan());
      Run
      
│ │ │ │ -
      source
      pub fn flatten(&self) -> &[T]
      🔬This is a nightly-only experimental API. (slice_flatten #95629)
      Takes a &[[T; N]], and flattens it to a &[T].
      
│ │ │ │ +
      source
      pub fn flatten(&self) -> &[T]
      🔬This is a nightly-only experimental API. (slice_flatten #95629)
      Takes a &[[T; N]], and flattens it to a &[T].
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      This panics if the length of the resulting slice would overflow a usize.
      
│ │ │ │  
      This is only possible when flattening a slice of arrays of zero-sized
│ │ │ │  types, and thus tends to be irrelevant in practice. If
│ │ │ │  size_of::<T>() > 0, this will never panic.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_flatten)]
│ │ │ │ @@ -1452,15 +1452,15 @@
│ │ │ │  );
│ │ │ │  
│ │ │ │  let slice_of_empty_arrays: &[[i32; 0]] = &[[], [], [], [], []];
│ │ │ │  assert!(slice_of_empty_arrays.flatten().is_empty());
│ │ │ │  
│ │ │ │  let empty_slice_of_arrays: &[[u32; 10]] = &[];
│ │ │ │  assert!(empty_slice_of_arrays.flatten().is_empty());
      Run
      
│ │ │ │ -
      source
      pub fn flatten_mut(&mut self) -> &mut [T]
      🔬This is a nightly-only experimental API. (slice_flatten #95629)
      Takes a &mut [[T; N]], and flattens it to a &mut [T].
      
│ │ │ │ +
      source
      pub fn flatten_mut(&mut self) -> &mut [T]
      🔬This is a nightly-only experimental API. (slice_flatten #95629)
      Takes a &mut [[T; N]], and flattens it to a &mut [T].
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      This panics if the length of the resulting slice would overflow a usize.
      
│ │ │ │  
      This is only possible when flattening a slice of arrays of zero-sized
│ │ │ │  types, and thus tends to be irrelevant in practice. If
│ │ │ │  size_of::<T>() > 0, this will never panic.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_flatten)]
│ │ │ │ @@ -1470,320 +1470,320 @@
│ │ │ │          *i += 5;
│ │ │ │      }
│ │ │ │  }
│ │ │ │  
│ │ │ │  let mut array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
│ │ │ │  add_5_to_all(array.flatten_mut());
│ │ │ │  assert_eq!(array, [[6, 7, 8], [9, 10, 11], [12, 13, 14]]);
      Run
      
│ │ │ │ -
      1.23.0 · source
      pub fn is_ascii(&self) -> bool
      Checks if all bytes in this slice are within the ASCII range.
      
│ │ │ │ -
      source
      pub fn as_ascii(&self) -> Option<&[AsciiChar]>
      🔬This is a nightly-only experimental API. (ascii_char #110998)
      If this slice is_ascii, returns it as a slice of
│ │ │ │ -ASCII characters, otherwise returns None.
      
│ │ │ │ -
      source
      pub unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar]
      🔬This is a nightly-only experimental API. (ascii_char #110998)
      Converts this slice of bytes into a slice of ASCII characters,
│ │ │ │ +
      1.23.0 · source
      pub fn is_ascii(&self) -> bool
      Checks if all bytes in this slice are within the ASCII range.
      
│ │ │ │ +
      source
      pub fn as_ascii(&self) -> Option<&[AsciiChar]>
      🔬This is a nightly-only experimental API. (ascii_char #110998)
      If this slice is_ascii, returns it as a slice of
│ │ │ │ +ASCII characters, otherwise returns None.
      
│ │ │ │ +
      source
      pub unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar]
      🔬This is a nightly-only experimental API. (ascii_char #110998)
      Converts this slice of bytes into a slice of ASCII characters,
│ │ │ │  without checking whether they’re valid.
      
│ │ │ │  
      §Safety
      
│ │ │ │  
      Every byte in the slice must be in 0..=127, or else this is UB.
      
│ │ │ │ -
      1.23.0 · source
      pub fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool
      Checks that two slices are an ASCII case-insensitive match.
      
│ │ │ │ +
      1.23.0 · source
      pub fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool
      Checks that two slices are an ASCII case-insensitive match.
      
│ │ │ │  
      Same as to_ascii_lowercase(a) == to_ascii_lowercase(b),
│ │ │ │  but without allocating and copying temporaries.
      
│ │ │ │ -
      1.23.0 · source
      pub fn make_ascii_uppercase(&mut self)
      Converts this slice to its ASCII upper case equivalent in-place.
      
│ │ │ │ +
      1.23.0 · source
      pub fn make_ascii_uppercase(&mut self)
      Converts this slice to its ASCII upper case equivalent in-place.
      
│ │ │ │  
      ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’,
│ │ │ │  but non-ASCII letters are unchanged.
      
│ │ │ │  
      To return a new uppercased value without modifying the existing one, use
│ │ │ │  to_ascii_uppercase.
      
│ │ │ │ -
      1.23.0 · source
      pub fn make_ascii_lowercase(&mut self)
      Converts this slice to its ASCII lower case equivalent in-place.
      
│ │ │ │ +
      1.23.0 · source
      pub fn make_ascii_lowercase(&mut self)
      Converts this slice to its ASCII lower case equivalent in-place.
      
│ │ │ │  
      ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’,
│ │ │ │  but non-ASCII letters are unchanged.
      
│ │ │ │  
      To return a new lowercased value without modifying the existing one, use
│ │ │ │  to_ascii_lowercase.
      
│ │ │ │ -
      1.60.0 · source
      pub fn escape_ascii(&self) -> EscapeAscii<'_> ⓘ
      Returns an iterator that produces an escaped version of this slice,
│ │ │ │ +
      1.60.0 · source
      pub fn escape_ascii(&self) -> EscapeAscii<'_> ⓘ
      Returns an iterator that produces an escaped version of this slice,
│ │ │ │  treating it as an ASCII string.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      
│ │ │ │  let s = b"0\t\r\n'\"\\\x9d";
│ │ │ │  let escaped = s.escape_ascii().to_string();
│ │ │ │  assert_eq!(escaped, "0\\t\\r\\n\\'\\\"\\\\\\x9d");
      Run
      
│ │ │ │ -
      source
      pub fn trim_ascii_start(&self) -> &[u8]
      🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
      Returns a byte slice with leading ASCII whitespace bytes removed.
      
│ │ │ │ +
      source
      pub fn trim_ascii_start(&self) -> &[u8]
      🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
      Returns a byte slice with leading ASCII whitespace bytes removed.
      
│ │ │ │  
      ‘Whitespace’ refers to the definition used by
│ │ │ │  u8::is_ascii_whitespace.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(byte_slice_trim_ascii)]
│ │ │ │  
│ │ │ │  assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
│ │ │ │  assert_eq!(b"  ".trim_ascii_start(), b"");
│ │ │ │  assert_eq!(b"".trim_ascii_start(), b"");
      Run
      
│ │ │ │ -
      source
      pub fn trim_ascii_end(&self) -> &[u8]
      🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
      Returns a byte slice with trailing ASCII whitespace bytes removed.
      
│ │ │ │ +
      source
      pub fn trim_ascii_end(&self) -> &[u8]
      🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
      Returns a byte slice with trailing ASCII whitespace bytes removed.
      
│ │ │ │  
      ‘Whitespace’ refers to the definition used by
│ │ │ │  u8::is_ascii_whitespace.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(byte_slice_trim_ascii)]
│ │ │ │  
│ │ │ │  assert_eq!(b"\r hello world\n ".trim_ascii_end(), b"\r hello world");
│ │ │ │  assert_eq!(b"  ".trim_ascii_end(), b"");
│ │ │ │  assert_eq!(b"".trim_ascii_end(), b"");
      Run
      
│ │ │ │ -
      source
      pub fn trim_ascii(&self) -> &[u8]
      🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
      Returns a byte slice with leading and trailing ASCII whitespace bytes
│ │ │ │ +
      source
      pub fn trim_ascii(&self) -> &[u8]
      🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)
      Returns a byte slice with leading and trailing ASCII whitespace bytes
│ │ │ │  removed.
      
│ │ │ │  
      ‘Whitespace’ refers to the definition used by
│ │ │ │  u8::is_ascii_whitespace.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(byte_slice_trim_ascii)]
│ │ │ │  
│ │ │ │  assert_eq!(b"\r hello world\n ".trim_ascii(), b"hello world");
│ │ │ │  assert_eq!(b"  ".trim_ascii(), b"");
│ │ │ │  assert_eq!(b"".trim_ascii(), b"");
      Run
      
│ │ │ │ -
      source
      pub fn sort_floats(&mut self)
      🔬This is a nightly-only experimental API. (sort_floats #93396)
      Sorts the slice of floats.
      
│ │ │ │ +
      source
      pub fn sort_floats(&mut self)
      🔬This is a nightly-only experimental API. (sort_floats #93396)
      Sorts the slice of floats.
      
│ │ │ │  
      This sort is in-place (i.e. does not allocate), O(n * log(n)) worst-case, and uses
│ │ │ │ -the ordering defined by f64::total_cmp.
      
│ │ │ │ +the ordering defined by f64::total_cmp.
      
│ │ │ │  
      §Current implementation
      
│ │ │ │ -
      This uses the same sorting algorithm as sort_unstable_by.
      
│ │ │ │ +
      This uses the same sorting algorithm as sort_unstable_by.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(sort_floats)]
│ │ │ │  let mut v = [2.6, -5e-8, f64::NAN, 8.29, f64::INFINITY, -1.0, 0.0, -f64::INFINITY, -0.0];
│ │ │ │  
│ │ │ │  v.sort_floats();
│ │ │ │  let sorted = [-f64::INFINITY, -1.0, -5e-8, -0.0, 0.0, 2.6, 8.29, f64::INFINITY, f64::NAN];
│ │ │ │  assert_eq!(&v[..8], &sorted[..8]);
│ │ │ │  assert!(v[8].is_nan());
      Run
      
│ │ │ │ -
      source
      pub fn len(&self) -> usize
      Returns the number of elements in the slice.
      
│ │ │ │ +
      source
      pub fn len(&self) -> usize
      Returns the number of elements in the slice.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let a = [1, 2, 3];
│ │ │ │  assert_eq!(a.len(), 3);
      Run
      
│ │ │ │ -
      source
      pub fn is_empty(&self) -> bool
      Returns true if the slice has a length of 0.
      
│ │ │ │ +
      source
      pub fn is_empty(&self) -> bool
      Returns true if the slice has a length of 0.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let a = [1, 2, 3];
│ │ │ │  assert!(!a.is_empty());
│ │ │ │  
│ │ │ │  let b: &[i32] = &[];
│ │ │ │  assert!(b.is_empty());
      Run
      
│ │ │ │ -
      source
      pub fn first(&self) -> Option<&T>
      Returns the first element of the slice, or None if it is empty.
      
│ │ │ │ +
      source
      pub fn first(&self) -> Option<&T>
      Returns the first element of the slice, or None if it is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = [10, 40, 30];
│ │ │ │  assert_eq!(Some(&10), v.first());
│ │ │ │  
│ │ │ │  let w: &[i32] = &[];
│ │ │ │  assert_eq!(None, w.first());
      Run
      
│ │ │ │ -
      source
      pub fn first_mut(&mut self) -> Option<&mut T>
      Returns a mutable pointer to the first element of the slice, or None if it is empty.
      
│ │ │ │ +
      source
      pub fn first_mut(&mut self) -> Option<&mut T>
      Returns a mutable pointer to the first element of the slice, or None if it is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &mut [0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some(first) = x.first_mut() {
│ │ │ │      *first = 5;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[5, 1, 2]);
│ │ │ │  
│ │ │ │  let y: &mut [i32] = &mut [];
│ │ │ │  assert_eq!(None, y.first_mut());
      Run
      
│ │ │ │ -
      1.5.0 · source
      pub fn split_first(&self) -> Option<(&T, &[T])>
      Returns the first and all the rest of the elements of the slice, or None if it is empty.
      
│ │ │ │ +
      1.5.0 · source
      pub fn split_first(&self) -> Option<(&T, &[T])>
      Returns the first and all the rest of the elements of the slice, or None if it is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &[0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some((first, elements)) = x.split_first() {
│ │ │ │      assert_eq!(first, &0);
│ │ │ │      assert_eq!(elements, &[1, 2]);
│ │ │ │  }
      Run
      
│ │ │ │ -
      1.5.0 · source
      pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>
      Returns the first and all the rest of the elements of the slice, or None if it is empty.
      
│ │ │ │ +
      1.5.0 · source
      pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>
      Returns the first and all the rest of the elements of the slice, or None if it is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &mut [0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some((first, elements)) = x.split_first_mut() {
│ │ │ │      *first = 3;
│ │ │ │      elements[0] = 4;
│ │ │ │      elements[1] = 5;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[3, 4, 5]);
      Run
      
│ │ │ │ -
      1.5.0 · source
      pub fn split_last(&self) -> Option<(&T, &[T])>
      Returns the last and all the rest of the elements of the slice, or None if it is empty.
      
│ │ │ │ +
      1.5.0 · source
      pub fn split_last(&self) -> Option<(&T, &[T])>
      Returns the last and all the rest of the elements of the slice, or None if it is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &[0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some((last, elements)) = x.split_last() {
│ │ │ │      assert_eq!(last, &2);
│ │ │ │      assert_eq!(elements, &[0, 1]);
│ │ │ │  }
      Run
      
│ │ │ │ -
      1.5.0 · source
      pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])>
      Returns the last and all the rest of the elements of the slice, or None if it is empty.
      
│ │ │ │ +
      1.5.0 · source
      pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])>
      Returns the last and all the rest of the elements of the slice, or None if it is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &mut [0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some((last, elements)) = x.split_last_mut() {
│ │ │ │      *last = 3;
│ │ │ │      elements[0] = 4;
│ │ │ │      elements[1] = 5;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[4, 5, 3]);
      Run
      
│ │ │ │ -
      source
      pub fn last(&self) -> Option<&T>
      Returns the last element of the slice, or None if it is empty.
      
│ │ │ │ +
      source
      pub fn last(&self) -> Option<&T>
      Returns the last element of the slice, or None if it is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = [10, 40, 30];
│ │ │ │  assert_eq!(Some(&30), v.last());
│ │ │ │  
│ │ │ │  let w: &[i32] = &[];
│ │ │ │  assert_eq!(None, w.last());
      Run
      
│ │ │ │ -
      source
      pub fn last_mut(&mut self) -> Option<&mut T>
      Returns a mutable reference to the last item in the slice, or None if it is empty.
      
│ │ │ │ +
      source
      pub fn last_mut(&mut self) -> Option<&mut T>
      Returns a mutable reference to the last item in the slice, or None if it is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &mut [0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some(last) = x.last_mut() {
│ │ │ │      *last = 10;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[0, 1, 10]);
│ │ │ │  
│ │ │ │  let y: &mut [i32] = &mut [];
│ │ │ │  assert_eq!(None, y.last_mut());
      Run
      
│ │ │ │ -
      1.77.0 · source
      pub fn first_chunk<const N: usize>(&self) -> Option<&[T; N]>
      Return an array reference to the first N items in the slice.
      
│ │ │ │ +
      1.77.0 · source
      pub fn first_chunk<const N: usize>(&self) -> Option<&[T; N]>
      Return an array reference to the first N items in the slice.
      
│ │ │ │  
      If the slice is not at least N in length, this will return None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let u = [10, 40, 30];
│ │ │ │  assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());
│ │ │ │  
│ │ │ │  let v: &[i32] = &[10];
│ │ │ │  assert_eq!(None, v.first_chunk::<2>());
│ │ │ │  
│ │ │ │  let w: &[i32] = &[];
│ │ │ │  assert_eq!(Some(&[]), w.first_chunk::<0>());
      Run
      
│ │ │ │ -
      1.77.0 · source
      pub fn first_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>
      Return a mutable array reference to the first N items in the slice.
      
│ │ │ │ +
      1.77.0 · source
      pub fn first_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>
      Return a mutable array reference to the first N items in the slice.
      
│ │ │ │  
      If the slice is not at least N in length, this will return None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &mut [0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some(first) = x.first_chunk_mut::<2>() {
│ │ │ │      first[0] = 5;
│ │ │ │      first[1] = 4;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[5, 4, 2]);
│ │ │ │  
│ │ │ │  assert_eq!(None, x.first_chunk_mut::<4>());
      Run
      
│ │ │ │ -
      1.77.0 · source
      pub fn split_first_chunk<const N: usize>(&self) -> Option<(&[T; N], &[T])>
      Return an array reference to the first N items in the slice and the remaining slice.
      
│ │ │ │ +
      1.77.0 · source
      pub fn split_first_chunk<const N: usize>(&self) -> Option<(&[T; N], &[T])>
      Return an array reference to the first N items in the slice and the remaining slice.
      
│ │ │ │  
      If the slice is not at least N in length, this will return None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &[0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some((first, elements)) = x.split_first_chunk::<2>() {
│ │ │ │      assert_eq!(first, &[0, 1]);
│ │ │ │      assert_eq!(elements, &[2]);
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(None, x.split_first_chunk::<4>());
      Run
      
│ │ │ │ -
      1.77.0 · source
      pub fn split_first_chunk_mut<const N: usize>(
│ │ │ │ +
      1.77.0 · source
      pub fn split_first_chunk_mut<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Option<(&mut [T; N], &mut [T])>
      Return a mutable array reference to the first N items in the slice and the remaining
│ │ │ │ +) -> Option<(&mut [T; N], &mut [T])>
      Return a mutable array reference to the first N items in the slice and the remaining
│ │ │ │  slice.
      
│ │ │ │  
      If the slice is not at least N in length, this will return None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &mut [0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some((first, elements)) = x.split_first_chunk_mut::<2>() {
│ │ │ │      first[0] = 3;
│ │ │ │      first[1] = 4;
│ │ │ │      elements[0] = 5;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[3, 4, 5]);
│ │ │ │  
│ │ │ │  assert_eq!(None, x.split_first_chunk_mut::<4>());
      Run
      
│ │ │ │ -
      1.77.0 · source
      pub fn split_last_chunk<const N: usize>(&self) -> Option<(&[T], &[T; N])>
      Return an array reference to the last N items in the slice and the remaining slice.
      
│ │ │ │ +
      1.77.0 · source
      pub fn split_last_chunk<const N: usize>(&self) -> Option<(&[T], &[T; N])>
      Return an array reference to the last N items in the slice and the remaining slice.
      
│ │ │ │  
      If the slice is not at least N in length, this will return None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &[0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some((elements, last)) = x.split_last_chunk::<2>() {
│ │ │ │      assert_eq!(elements, &[0]);
│ │ │ │      assert_eq!(last, &[1, 2]);
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(None, x.split_last_chunk::<4>());
      Run
      
│ │ │ │ -
      1.77.0 · source
      pub fn split_last_chunk_mut<const N: usize>(
│ │ │ │ +
      1.77.0 · source
      pub fn split_last_chunk_mut<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> Option<(&mut [T], &mut [T; N])>
      Return a mutable array reference to the last N items in the slice and the remaining
│ │ │ │ +) -> Option<(&mut [T], &mut [T; N])>
      Return a mutable array reference to the last N items in the slice and the remaining
│ │ │ │  slice.
      
│ │ │ │  
      If the slice is not at least N in length, this will return None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &mut [0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some((elements, last)) = x.split_last_chunk_mut::<2>() {
│ │ │ │      last[0] = 3;
│ │ │ │      last[1] = 4;
│ │ │ │      elements[0] = 5;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[5, 3, 4]);
│ │ │ │  
│ │ │ │  assert_eq!(None, x.split_last_chunk_mut::<4>());
      Run
      
│ │ │ │ -
      1.77.0 · source
      pub fn last_chunk<const N: usize>(&self) -> Option<&[T; N]>
      Return an array reference to the last N items in the slice.
      
│ │ │ │ +
      1.77.0 · source
      pub fn last_chunk<const N: usize>(&self) -> Option<&[T; N]>
      Return an array reference to the last N items in the slice.
      
│ │ │ │  
      If the slice is not at least N in length, this will return None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let u = [10, 40, 30];
│ │ │ │  assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());
│ │ │ │  
│ │ │ │  let v: &[i32] = &[10];
│ │ │ │  assert_eq!(None, v.last_chunk::<2>());
│ │ │ │  
│ │ │ │  let w: &[i32] = &[];
│ │ │ │  assert_eq!(Some(&[]), w.last_chunk::<0>());
      Run
      
│ │ │ │ -
      1.77.0 · source
      pub fn last_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>
      Return a mutable array reference to the last N items in the slice.
      
│ │ │ │ +
      1.77.0 · source
      pub fn last_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>
      Return a mutable array reference to the last N items in the slice.
      
│ │ │ │  
      If the slice is not at least N in length, this will return None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &mut [0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some(last) = x.last_chunk_mut::<2>() {
│ │ │ │      last[0] = 10;
│ │ │ │      last[1] = 20;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[0, 10, 20]);
│ │ │ │  
│ │ │ │  assert_eq!(None, x.last_chunk_mut::<4>());
      Run
      
│ │ │ │ -
      source
      pub fn get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output>
      where
│ │ │ │ -    I: SliceIndex<[T]>,
      Returns a reference to an element or subslice depending on the type of
│ │ │ │ +
      source
      pub fn get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output>
      where
│ │ │ │ +    I: SliceIndex<[T]>,
      Returns a reference to an element or subslice depending on the type of
│ │ │ │  index.
      
│ │ │ │  
        
│ │ │ │  
      • If given a position, returns a reference to the element at that
│ │ │ │  position or None if out of bounds.
        • 
│ │ │ │  
      • If given a range, returns the subslice corresponding to that range,
│ │ │ │  or None if out of bounds.
        • 
│ │ │ │  
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = [10, 40, 30];
│ │ │ │  assert_eq!(Some(&40), v.get(1));
│ │ │ │  assert_eq!(Some(&[10, 40][..]), v.get(0..2));
│ │ │ │  assert_eq!(None, v.get(3));
│ │ │ │  assert_eq!(None, v.get(0..4));
      Run
      
│ │ │ │ -
      source
      pub fn get_mut<I>(
│ │ │ │ +
      source
      pub fn get_mut<I>(
│ │ │ │      &mut self,
│ │ │ │      index: I
│ │ │ │ -) -> Option<&mut <I as SliceIndex<[T]>>::Output>
      where
│ │ │ │ -    I: SliceIndex<[T]>,
      Returns a mutable reference to an element or subslice depending on the
│ │ │ │ -type of index (see get) or None if the index is out of bounds.
      
│ │ │ │ +) -> Option<&mut <I as SliceIndex<[T]>>::Output>
      where
│ │ │ │ +    I: SliceIndex<[T]>,
      Returns a mutable reference to an element or subslice depending on the
│ │ │ │ +type of index (see get) or None if the index is out of bounds.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &mut [0, 1, 2];
│ │ │ │  
│ │ │ │  if let Some(elem) = x.get_mut(1) {
│ │ │ │      *elem = 42;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[0, 42, 2]);
      Run
      
│ │ │ │ -
      source
      pub unsafe fn get_unchecked<I>(
│ │ │ │ +
      source
      pub unsafe fn get_unchecked<I>(
│ │ │ │      &self,
│ │ │ │      index: I
│ │ │ │ -) -> &<I as SliceIndex<[T]>>::Output
      where
│ │ │ │ -    I: SliceIndex<[T]>,
      Returns a reference to an element or subslice, without doing bounds
│ │ │ │ +) -> &<I as SliceIndex<[T]>>::Output
      where
│ │ │ │ +    I: SliceIndex<[T]>,
      Returns a reference to an element or subslice, without doing bounds
│ │ │ │  checking.
      
│ │ │ │ -
      For a safe alternative see get.
      
│ │ │ │ +
      For a safe alternative see get.
      
│ │ │ │  
      §Safety
      
│ │ │ │  
      Calling this method with an out-of-bounds index is undefined behavior
│ │ │ │  even if the resulting reference is not used.
      
│ │ │ │  
      You can think of this like .get(index).unwrap_unchecked().  It’s UB
│ │ │ │  to call .get_unchecked(len), even if you immediately convert to a
│ │ │ │  pointer.  And it’s UB to call .get_unchecked(..len + 1),
│ │ │ │  .get_unchecked(..=len), or similar.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &[1, 2, 4];
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      assert_eq!(x.get_unchecked(1), &2);
│ │ │ │  }
      Run
      
│ │ │ │ -
      source
      pub unsafe fn get_unchecked_mut<I>(
│ │ │ │ +
      source
      pub unsafe fn get_unchecked_mut<I>(
│ │ │ │      &mut self,
│ │ │ │      index: I
│ │ │ │ -) -> &mut <I as SliceIndex<[T]>>::Output
      where
│ │ │ │ -    I: SliceIndex<[T]>,
      Returns a mutable reference to an element or subslice, without doing
│ │ │ │ +) -> &mut <I as SliceIndex<[T]>>::Output
      where
│ │ │ │ +    I: SliceIndex<[T]>,
      Returns a mutable reference to an element or subslice, without doing
│ │ │ │  bounds checking.
      
│ │ │ │ -
      For a safe alternative see get_mut.
      
│ │ │ │ +
      For a safe alternative see get_mut.
      
│ │ │ │  
      §Safety
      
│ │ │ │  
      Calling this method with an out-of-bounds index is undefined behavior
│ │ │ │  even if the resulting reference is not used.
      
│ │ │ │  
      You can think of this like .get_mut(index).unwrap_unchecked().  It’s
│ │ │ │  UB to call .get_unchecked_mut(len), even if you immediately convert
│ │ │ │  to a pointer.  And it’s UB to call .get_unchecked_mut(..len + 1),
│ │ │ │  .get_unchecked_mut(..=len), or similar.
      
│ │ │ │ @@ -1791,92 +1791,92 @@
│ │ │ │  
      let x = &mut [1, 2, 4];
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      let elem = x.get_unchecked_mut(1);
│ │ │ │      *elem = 13;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[1, 13, 4]);
      Run
      
│ │ │ │ -
      source
      pub fn as_ptr(&self) -> *const T
      Returns a raw pointer to the slice’s buffer.
      
│ │ │ │ +
      source
      pub fn as_ptr(&self) -> *const T
      Returns a raw pointer to the slice’s buffer.
      
│ │ │ │  
      The caller must ensure that the slice outlives the pointer this
│ │ │ │  function returns, or else it will end up pointing to garbage.
      
│ │ │ │  
      The caller must also ensure that the memory the pointer (non-transitively) points to
│ │ │ │  is never written to (except inside an UnsafeCell) using this pointer or any pointer
│ │ │ │ -derived from it. If you need to mutate the contents of the slice, use as_mut_ptr.
      
│ │ │ │ +derived from it. If you need to mutate the contents of the slice, use as_mut_ptr.
      
│ │ │ │  
      Modifying the container referenced by this slice may cause its buffer
│ │ │ │  to be reallocated, which would also make any pointers to it invalid.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &[1, 2, 4];
│ │ │ │  let x_ptr = x.as_ptr();
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      for i in 0..x.len() {
│ │ │ │          assert_eq!(x.get_unchecked(i), &*x_ptr.add(i));
│ │ │ │      }
│ │ │ │  }
      Run
      
│ │ │ │ -
      source
      pub fn as_mut_ptr(&mut self) -> *mut T
      Returns an unsafe mutable pointer to the slice’s buffer.
      
│ │ │ │ +
      source
      pub fn as_mut_ptr(&mut self) -> *mut T
      Returns an unsafe mutable pointer to the slice’s buffer.
      
│ │ │ │  
      The caller must ensure that the slice outlives the pointer this
│ │ │ │  function returns, or else it will end up pointing to garbage.
      
│ │ │ │  
      Modifying the container referenced by this slice may cause its buffer
│ │ │ │  to be reallocated, which would also make any pointers to it invalid.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &mut [1, 2, 4];
│ │ │ │  let x_ptr = x.as_mut_ptr();
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      for i in 0..x.len() {
│ │ │ │          *x_ptr.add(i) += 2;
│ │ │ │      }
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[3, 4, 6]);
      Run
      
│ │ │ │ -
      1.48.0 · source
      pub fn as_ptr_range(&self) -> Range<*const T>
      Returns the two raw pointers spanning the slice.
      
│ │ │ │ +
      1.48.0 · source
      pub fn as_ptr_range(&self) -> Range<*const T>
      Returns the two raw pointers spanning the slice.
      
│ │ │ │  
      The returned range is half-open, which means that the end pointer
│ │ │ │  points one past the last element of the slice. This way, an empty
│ │ │ │  slice is represented by two equal pointers, and the difference between
│ │ │ │  the two pointers represents the size of the slice.
      
│ │ │ │ -
      See as_ptr for warnings on using these pointers. The end pointer
│ │ │ │ +
      See as_ptr for warnings on using these pointers. The end pointer
│ │ │ │  requires extra caution, as it does not point to a valid element in the
│ │ │ │  slice.
      
│ │ │ │  
      This function is useful for interacting with foreign interfaces which
│ │ │ │  use two pointers to refer to a range of elements in memory, as is
│ │ │ │  common in C++.
      
│ │ │ │  
      It can also be useful to check if a pointer to an element refers to an
│ │ │ │  element of this slice:
      
│ │ │ │  
│ │ │ │  
      let a = [1, 2, 3];
│ │ │ │  let x = &a[1] as *const _;
│ │ │ │  let y = &5 as *const _;
│ │ │ │  
│ │ │ │  assert!(a.as_ptr_range().contains(&x));
│ │ │ │  assert!(!a.as_ptr_range().contains(&y));
      Run
      
│ │ │ │ -
      1.48.0 · source
      pub fn as_mut_ptr_range(&mut self) -> Range<*mut T>
      Returns the two unsafe mutable pointers spanning the slice.
      
│ │ │ │ +
      1.48.0 · source
      pub fn as_mut_ptr_range(&mut self) -> Range<*mut T>
      Returns the two unsafe mutable pointers spanning the slice.
      
│ │ │ │  
      The returned range is half-open, which means that the end pointer
│ │ │ │  points one past the last element of the slice. This way, an empty
│ │ │ │  slice is represented by two equal pointers, and the difference between
│ │ │ │  the two pointers represents the size of the slice.
      
│ │ │ │ -
      See as_mut_ptr for warnings on using these pointers. The end
│ │ │ │ +
      See as_mut_ptr for warnings on using these pointers. The end
│ │ │ │  pointer requires extra caution, as it does not point to a valid element
│ │ │ │  in the slice.
      
│ │ │ │  
      This function is useful for interacting with foreign interfaces which
│ │ │ │  use two pointers to refer to a range of elements in memory, as is
│ │ │ │  common in C++.
      
│ │ │ │ -
      source
      pub fn swap(&mut self, a: usize, b: usize)
      Swaps two elements in the slice.
      
│ │ │ │ +
      source
      pub fn swap(&mut self, a: usize, b: usize)
      Swaps two elements in the slice.
      
│ │ │ │  
      If a equals to b, it’s guaranteed that elements won’t change value.
      
│ │ │ │  
      §Arguments
      
│ │ │ │  
        
│ │ │ │  
      • a - The index of the first element
        • 
│ │ │ │  
      • b - The index of the second element
        • 
│ │ │ │  
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if a or b are out of bounds.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = ["a", "b", "c", "d", "e"];
│ │ │ │  v.swap(2, 4);
│ │ │ │  assert!(v == ["a", "b", "e", "d", "c"]);
      Run
      
│ │ │ │ -
      source
      pub unsafe fn swap_unchecked(&mut self, a: usize, b: usize)
      🔬This is a nightly-only experimental API. (slice_swap_unchecked #88539)
      Swaps two elements in the slice, without doing bounds checking.
      
│ │ │ │ -
      For a safe alternative see swap.
      
│ │ │ │ +
      source
      pub unsafe fn swap_unchecked(&mut self, a: usize, b: usize)
      🔬This is a nightly-only experimental API. (slice_swap_unchecked #88539)
      Swaps two elements in the slice, without doing bounds checking.
      
│ │ │ │ +
      For a safe alternative see swap.
      
│ │ │ │  
      §Arguments
      
│ │ │ │  
        
│ │ │ │  
      • a - The index of the first element
        • 
│ │ │ │  
      • b - The index of the second element
        • 
│ │ │ │  
      
│ │ │ │  
      §Safety
      
│ │ │ │  
      Calling this method with an out-of-bounds index is undefined behavior.
│ │ │ │ @@ -1884,38 +1884,38 @@
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_swap_unchecked)]
│ │ │ │  
│ │ │ │  let mut v = ["a", "b", "c", "d"];
│ │ │ │  // SAFETY: we know that 1 and 3 are both indices of the slice
│ │ │ │  unsafe { v.swap_unchecked(1, 3) };
│ │ │ │  assert!(v == ["a", "d", "c", "b"]);
      Run
      
│ │ │ │ -
      source
      pub fn reverse(&mut self)
      Reverses the order of elements in the slice, in place.
      
│ │ │ │ +
      source
      pub fn reverse(&mut self)
      Reverses the order of elements in the slice, in place.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [1, 2, 3];
│ │ │ │  v.reverse();
│ │ │ │  assert!(v == [3, 2, 1]);
      Run
      
│ │ │ │ -
      source
      pub fn iter(&self) -> Iter<'_, T> ⓘ
      Returns an iterator over the slice.
      
│ │ │ │ +
      source
      pub fn iter(&self) -> Iter<'_, T> ⓘ
      Returns an iterator over the slice.
      
│ │ │ │  
      The iterator yields all items from start to end.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &[1, 2, 4];
│ │ │ │  let mut iterator = x.iter();
│ │ │ │  
│ │ │ │  assert_eq!(iterator.next(), Some(&1));
│ │ │ │  assert_eq!(iterator.next(), Some(&2));
│ │ │ │  assert_eq!(iterator.next(), Some(&4));
│ │ │ │  assert_eq!(iterator.next(), None);
      Run
      
│ │ │ │ -
      source
      pub fn iter_mut(&mut self) -> IterMut<'_, T> ⓘ
      Returns an iterator that allows modifying each value.
      
│ │ │ │ +
      source
      pub fn iter_mut(&mut self) -> IterMut<'_, T> ⓘ
      Returns an iterator that allows modifying each value.
      
│ │ │ │  
      The iterator yields all items from start to end.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let x = &mut [1, 2, 4];
│ │ │ │  for elem in x.iter_mut() {
│ │ │ │      *elem += 2;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[3, 4, 6]);
      Run
      
│ │ │ │ -
      source
      pub fn windows(&self, size: usize) -> Windows<'_, T> ⓘ
      Returns an iterator over all contiguous windows of length
│ │ │ │ +
      source
      pub fn windows(&self, size: usize) -> Windows<'_, T> ⓘ
      Returns an iterator over all contiguous windows of length
│ │ │ │  size. The windows overlap. If the slice is shorter than
│ │ │ │  size, the iterator returns no values.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if size is 0.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let mut iter = slice.windows(3);
│ │ │ │ @@ -1926,104 +1926,104 @@
│ │ │ │  
      If the slice is shorter than size:
      
│ │ │ │  
│ │ │ │  
      let slice = ['f', 'o', 'o'];
│ │ │ │  let mut iter = slice.windows(4);
│ │ │ │  assert!(iter.next().is_none());
      Run
      
│ │ │ │  
      There’s no windows_mut, as that existing would let safe code violate the
│ │ │ │  “only one &mut at a time to the same thing” rule.  However, you can sometimes
│ │ │ │ -use Cell::as_slice_of_cells in
│ │ │ │ +use Cell::as_slice_of_cells in
│ │ │ │  conjunction with windows to accomplish something similar:
      
│ │ │ │  
│ │ │ │  
      use std::cell::Cell;
│ │ │ │  
│ │ │ │  let mut array = ['R', 'u', 's', 't', ' ', '2', '0', '1', '5'];
│ │ │ │  let slice = &mut array[..];
│ │ │ │  let slice_of_cells: &[Cell<char>] = Cell::from_mut(slice).as_slice_of_cells();
│ │ │ │  for w in slice_of_cells.windows(3) {
│ │ │ │      Cell::swap(&w[0], &w[2]);
│ │ │ │  }
│ │ │ │  assert_eq!(array, ['s', 't', ' ', '2', '0', '1', '5', 'u', 'R']);
      Run
      
│ │ │ │ -
      source
      pub fn chunks(&self, chunk_size: usize) -> Chunks<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the
│ │ │ │ +
      source
      pub fn chunks(&self, chunk_size: usize) -> Chunks<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the
│ │ │ │  beginning of the slice.
      
│ │ │ │  
      The chunks are slices and do not overlap. If chunk_size does not divide the length of the
│ │ │ │  slice, then the last chunk will not have length chunk_size.
      
│ │ │ │ -
      See chunks_exact for a variant of this iterator that returns chunks of always exactly
│ │ │ │ -chunk_size elements, and rchunks for the same iterator but starting at the end of the
│ │ │ │ +
      See chunks_exact for a variant of this iterator that returns chunks of always exactly
│ │ │ │ +chunk_size elements, and rchunks for the same iterator but starting at the end of the
│ │ │ │  slice.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if chunk_size is 0.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let mut iter = slice.chunks(2);
│ │ │ │  assert_eq!(iter.next().unwrap(), &['l', 'o']);
│ │ │ │  assert_eq!(iter.next().unwrap(), &['r', 'e']);
│ │ │ │  assert_eq!(iter.next().unwrap(), &['m']);
│ │ │ │  assert!(iter.next().is_none());
      Run
      
│ │ │ │ -
      source
      pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the
│ │ │ │ +
      source
      pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the
│ │ │ │  beginning of the slice.
      
│ │ │ │  
      The chunks are mutable slices, and do not overlap. If chunk_size does not divide the
│ │ │ │  length of the slice, then the last chunk will not have length chunk_size.
      
│ │ │ │ -
      See chunks_exact_mut for a variant of this iterator that returns chunks of always
│ │ │ │ -exactly chunk_size elements, and rchunks_mut for the same iterator but starting at
│ │ │ │ +
      See chunks_exact_mut for a variant of this iterator that returns chunks of always
│ │ │ │ +exactly chunk_size elements, and rchunks_mut for the same iterator but starting at
│ │ │ │  the end of the slice.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if chunk_size is 0.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = &mut [0, 0, 0, 0, 0];
│ │ │ │  let mut count = 1;
│ │ │ │  
│ │ │ │  for chunk in v.chunks_mut(2) {
│ │ │ │      for elem in chunk.iter_mut() {
│ │ │ │          *elem += count;
│ │ │ │      }
│ │ │ │      count += 1;
│ │ │ │  }
│ │ │ │  assert_eq!(v, &[1, 1, 2, 2, 3]);
      Run
      
│ │ │ │ -
      1.31.0 · source
      pub fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the
│ │ │ │ +
      1.31.0 · source
      pub fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the
│ │ │ │  beginning of the slice.
      
│ │ │ │  
      The chunks are slices and do not overlap. If chunk_size does not divide the length of the
│ │ │ │  slice, then the last up to chunk_size-1 elements will be omitted and can be retrieved
│ │ │ │  from the remainder function of the iterator.
      
│ │ │ │  
      Due to each chunk having exactly chunk_size elements, the compiler can often optimize the
│ │ │ │ -resulting code better than in the case of chunks.
      
│ │ │ │ -
      See chunks for a variant of this iterator that also returns the remainder as a smaller
│ │ │ │ -chunk, and rchunks_exact for the same iterator but starting at the end of the slice.
      
│ │ │ │ +resulting code better than in the case of chunks.
      
│ │ │ │ +
      See chunks for a variant of this iterator that also returns the remainder as a smaller
│ │ │ │ +chunk, and rchunks_exact for the same iterator but starting at the end of the slice.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if chunk_size is 0.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let mut iter = slice.chunks_exact(2);
│ │ │ │  assert_eq!(iter.next().unwrap(), &['l', 'o']);
│ │ │ │  assert_eq!(iter.next().unwrap(), &['r', 'e']);
│ │ │ │  assert!(iter.next().is_none());
│ │ │ │  assert_eq!(iter.remainder(), &['m']);
      Run
      
│ │ │ │ -
      1.31.0 · source
      pub fn chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the
│ │ │ │ +
      1.31.0 · source
      pub fn chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the
│ │ │ │  beginning of the slice.
      
│ │ │ │  
      The chunks are mutable slices, and do not overlap. If chunk_size does not divide the
│ │ │ │  length of the slice, then the last up to chunk_size-1 elements will be omitted and can be
│ │ │ │  retrieved from the into_remainder function of the iterator.
      
│ │ │ │  
      Due to each chunk having exactly chunk_size elements, the compiler can often optimize the
│ │ │ │ -resulting code better than in the case of chunks_mut.
      
│ │ │ │ -
      See chunks_mut for a variant of this iterator that also returns the remainder as a
│ │ │ │ -smaller chunk, and rchunks_exact_mut for the same iterator but starting at the end of
│ │ │ │ +resulting code better than in the case of chunks_mut.
      
│ │ │ │ +
      See chunks_mut for a variant of this iterator that also returns the remainder as a
│ │ │ │ +smaller chunk, and rchunks_exact_mut for the same iterator but starting at the end of
│ │ │ │  the slice.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if chunk_size is 0.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = &mut [0, 0, 0, 0, 0];
│ │ │ │  let mut count = 1;
│ │ │ │  
│ │ │ │  for chunk in v.chunks_exact_mut(2) {
│ │ │ │      for elem in chunk.iter_mut() {
│ │ │ │          *elem += count;
│ │ │ │      }
│ │ │ │      count += 1;
│ │ │ │  }
│ │ │ │  assert_eq!(v, &[1, 1, 2, 2, 0]);
      Run
      
│ │ │ │ -
      source
      pub unsafe fn as_chunks_unchecked<const N: usize>(&self) -> &[[T; N]]
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │ +
      source
      pub unsafe fn as_chunks_unchecked<const N: usize>(&self) -> &[[T; N]]
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │  assuming that there’s no remainder.
      
│ │ │ │  
      §Safety
      
│ │ │ │  
      This may only be called when
      
│ │ │ │  
        
│ │ │ │  
      • The slice splits exactly into N-element chunks (aka self.len() % N == 0).
        • 
│ │ │ │  
      • N != 0.
        • 
│ │ │ │  
      
│ │ │ │ @@ -2038,15 +2038,15 @@
│ │ │ │      // SAFETY: The slice length (6) is a multiple of 3
│ │ │ │      unsafe { slice.as_chunks_unchecked() };
│ │ │ │  assert_eq!(chunks, &[['l', 'o', 'r'], ['e', 'm', '!']]);
│ │ │ │  
│ │ │ │  // These would be unsound:
│ │ │ │  // let chunks: &[[_; 5]] = slice.as_chunks_unchecked() // The slice length is not a multiple of 5
│ │ │ │  // let chunks: &[[_; 0]] = slice.as_chunks_unchecked() // Zero-length chunks are never allowed      Run
      
│ │ │ │ -
      source
      pub fn as_chunks<const N: usize>(&self) -> (&[[T; N]], &[T])
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │ +
      source
      pub fn as_chunks<const N: usize>(&self) -> (&[[T; N]], &[T])
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │  starting at the beginning of the slice,
│ │ │ │  and a remainder slice with length strictly less than N.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if N is 0. This check will most probably get changed to a compile time
│ │ │ │  error before this method gets stabilized.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_as_chunks)]
│ │ │ │ @@ -2059,46 +2059,46 @@
│ │ │ │  
│ │ │ │  
      #![feature(slice_as_chunks)]
│ │ │ │  let slice = ['R', 'u', 's', 't'];
│ │ │ │  let (chunks, []) = slice.as_chunks::<2>() else {
│ │ │ │      panic!("slice didn't have even length")
│ │ │ │  };
│ │ │ │  assert_eq!(chunks, &[['R', 'u'], ['s', 't']]);
      Run
      
│ │ │ │ -
      source
      pub fn as_rchunks<const N: usize>(&self) -> (&[T], &[[T; N]])
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │ +
      source
      pub fn as_rchunks<const N: usize>(&self) -> (&[T], &[[T; N]])
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │  starting at the end of the slice,
│ │ │ │  and a remainder slice with length strictly less than N.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if N is 0. This check will most probably get changed to a compile time
│ │ │ │  error before this method gets stabilized.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_as_chunks)]
│ │ │ │  let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let (remainder, chunks) = slice.as_rchunks();
│ │ │ │  assert_eq!(remainder, &['l']);
│ │ │ │  assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
      Run
      
│ │ │ │ -
      source
      pub fn array_chunks<const N: usize>(&self) -> ArrayChunks<'_, T, N> ⓘ
      🔬This is a nightly-only experimental API. (array_chunks #74985)
      Returns an iterator over N elements of the slice at a time, starting at the
│ │ │ │ +
      source
      pub fn array_chunks<const N: usize>(&self) -> ArrayChunks<'_, T, N> ⓘ
      🔬This is a nightly-only experimental API. (array_chunks #74985)
      Returns an iterator over N elements of the slice at a time, starting at the
│ │ │ │  beginning of the slice.
      
│ │ │ │  
      The chunks are array references and do not overlap. If N does not divide the
│ │ │ │  length of the slice, then the last up to N-1 elements will be omitted and can be
│ │ │ │  retrieved from the remainder function of the iterator.
      
│ │ │ │ -
      This method is the const generic equivalent of chunks_exact.
      
│ │ │ │ +
      This method is the const generic equivalent of chunks_exact.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if N is 0. This check will most probably get changed to a compile time
│ │ │ │  error before this method gets stabilized.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(array_chunks)]
│ │ │ │  let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let mut iter = slice.array_chunks();
│ │ │ │  assert_eq!(iter.next().unwrap(), &['l', 'o']);
│ │ │ │  assert_eq!(iter.next().unwrap(), &['r', 'e']);
│ │ │ │  assert!(iter.next().is_none());
│ │ │ │  assert_eq!(iter.remainder(), &['m']);
      Run
      
│ │ │ │ -
      source
      pub unsafe fn as_chunks_unchecked_mut<const N: usize>(
│ │ │ │ +
      source
      pub unsafe fn as_chunks_unchecked_mut<const N: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> &mut [[T; N]]
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │ +) -> &mut [[T; N]]
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │  assuming that there’s no remainder.
      
│ │ │ │  
      §Safety
      
│ │ │ │  
      This may only be called when
      
│ │ │ │  
        
│ │ │ │  
      • The slice splits exactly into N-element chunks (aka self.len() % N == 0).
        • 
│ │ │ │  
      • N != 0.
        • 
│ │ │ │  
      
│ │ │ │ @@ -2115,15 +2115,15 @@
│ │ │ │      unsafe { slice.as_chunks_unchecked_mut() };
│ │ │ │  chunks[1] = ['a', 'x', '?'];
│ │ │ │  assert_eq!(slice, &['L', 'o', 'r', 'a', 'x', '?']);
│ │ │ │  
│ │ │ │  // These would be unsound:
│ │ │ │  // let chunks: &[[_; 5]] = slice.as_chunks_unchecked_mut() // The slice length is not a multiple of 5
│ │ │ │  // let chunks: &[[_; 0]] = slice.as_chunks_unchecked_mut() // Zero-length chunks are never allowed      Run
      
│ │ │ │ -
      source
      pub fn as_chunks_mut<const N: usize>(&mut self) -> (&mut [[T; N]], &mut [T])
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │ +
      source
      pub fn as_chunks_mut<const N: usize>(&mut self) -> (&mut [[T; N]], &mut [T])
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │  starting at the beginning of the slice,
│ │ │ │  and a remainder slice with length strictly less than N.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if N is 0. This check will most probably get changed to a compile time
│ │ │ │  error before this method gets stabilized.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_as_chunks)]
│ │ │ │ @@ -2133,15 +2133,15 @@
│ │ │ │  let (chunks, remainder) = v.as_chunks_mut();
│ │ │ │  remainder[0] = 9;
│ │ │ │  for chunk in chunks {
│ │ │ │      *chunk = [count; 2];
│ │ │ │      count += 1;
│ │ │ │  }
│ │ │ │  assert_eq!(v, &[1, 1, 2, 2, 9]);
      Run
      
│ │ │ │ -
      source
      pub fn as_rchunks_mut<const N: usize>(&mut self) -> (&mut [T], &mut [[T; N]])
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │ +
      source
      pub fn as_rchunks_mut<const N: usize>(&mut self) -> (&mut [T], &mut [[T; N]])
      🔬This is a nightly-only experimental API. (slice_as_chunks #74985)
      Splits the slice into a slice of N-element arrays,
│ │ │ │  starting at the end of the slice,
│ │ │ │  and a remainder slice with length strictly less than N.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if N is 0. This check will most probably get changed to a compile time
│ │ │ │  error before this method gets stabilized.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_as_chunks)]
│ │ │ │ @@ -2151,128 +2151,128 @@
│ │ │ │  let (remainder, chunks) = v.as_rchunks_mut();
│ │ │ │  remainder[0] = 9;
│ │ │ │  for chunk in chunks {
│ │ │ │      *chunk = [count; 2];
│ │ │ │      count += 1;
│ │ │ │  }
│ │ │ │  assert_eq!(v, &[9, 1, 1, 2, 2]);
      Run
      
│ │ │ │ -
      source
      pub fn array_chunks_mut<const N: usize>(&mut self) -> ArrayChunksMut<'_, T, N> ⓘ
      🔬This is a nightly-only experimental API. (array_chunks #74985)
      Returns an iterator over N elements of the slice at a time, starting at the
│ │ │ │ +
      source
      pub fn array_chunks_mut<const N: usize>(&mut self) -> ArrayChunksMut<'_, T, N> ⓘ
      🔬This is a nightly-only experimental API. (array_chunks #74985)
      Returns an iterator over N elements of the slice at a time, starting at the
│ │ │ │  beginning of the slice.
      
│ │ │ │  
      The chunks are mutable array references and do not overlap. If N does not divide
│ │ │ │  the length of the slice, then the last up to N-1 elements will be omitted and
│ │ │ │  can be retrieved from the into_remainder function of the iterator.
      
│ │ │ │ -
      This method is the const generic equivalent of chunks_exact_mut.
      
│ │ │ │ +
      This method is the const generic equivalent of chunks_exact_mut.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if N is 0. This check will most probably get changed to a compile time
│ │ │ │  error before this method gets stabilized.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(array_chunks)]
│ │ │ │  let v = &mut [0, 0, 0, 0, 0];
│ │ │ │  let mut count = 1;
│ │ │ │  
│ │ │ │  for chunk in v.array_chunks_mut() {
│ │ │ │      *chunk = [count; 2];
│ │ │ │      count += 1;
│ │ │ │  }
│ │ │ │  assert_eq!(v, &[1, 1, 2, 2, 0]);
      Run
      
│ │ │ │ -
      source
      pub fn array_windows<const N: usize>(&self) -> ArrayWindows<'_, T, N> ⓘ
      🔬This is a nightly-only experimental API. (array_windows #75027)
      Returns an iterator over overlapping windows of N elements of a slice,
│ │ │ │ +
      source
      pub fn array_windows<const N: usize>(&self) -> ArrayWindows<'_, T, N> ⓘ
      🔬This is a nightly-only experimental API. (array_windows #75027)
      Returns an iterator over overlapping windows of N elements of a slice,
│ │ │ │  starting at the beginning of the slice.
      
│ │ │ │ -
      This is the const generic equivalent of windows.
      
│ │ │ │ +
      This is the const generic equivalent of windows.
      
│ │ │ │  
      If N is greater than the size of the slice, it will return no windows.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if N is 0. This check will most probably get changed to a compile time
│ │ │ │  error before this method gets stabilized.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(array_windows)]
│ │ │ │  let slice = [0, 1, 2, 3];
│ │ │ │  let mut iter = slice.array_windows();
│ │ │ │  assert_eq!(iter.next().unwrap(), &[0, 1]);
│ │ │ │  assert_eq!(iter.next().unwrap(), &[1, 2]);
│ │ │ │  assert_eq!(iter.next().unwrap(), &[2, 3]);
│ │ │ │  assert!(iter.next().is_none());
      Run
      
│ │ │ │ -
      1.31.0 · source
      pub fn rchunks(&self, chunk_size: usize) -> RChunks<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the end
│ │ │ │ +
      1.31.0 · source
      pub fn rchunks(&self, chunk_size: usize) -> RChunks<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the end
│ │ │ │  of the slice.
      
│ │ │ │  
      The chunks are slices and do not overlap. If chunk_size does not divide the length of the
│ │ │ │  slice, then the last chunk will not have length chunk_size.
      
│ │ │ │ -
      See rchunks_exact for a variant of this iterator that returns chunks of always exactly
│ │ │ │ -chunk_size elements, and chunks for the same iterator but starting at the beginning
│ │ │ │ +
      See rchunks_exact for a variant of this iterator that returns chunks of always exactly
│ │ │ │ +chunk_size elements, and chunks for the same iterator but starting at the beginning
│ │ │ │  of the slice.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if chunk_size is 0.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let mut iter = slice.rchunks(2);
│ │ │ │  assert_eq!(iter.next().unwrap(), &['e', 'm']);
│ │ │ │  assert_eq!(iter.next().unwrap(), &['o', 'r']);
│ │ │ │  assert_eq!(iter.next().unwrap(), &['l']);
│ │ │ │  assert!(iter.next().is_none());
      Run
      
│ │ │ │ -
      1.31.0 · source
      pub fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the end
│ │ │ │ +
      1.31.0 · source
      pub fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the end
│ │ │ │  of the slice.
      
│ │ │ │  
      The chunks are mutable slices, and do not overlap. If chunk_size does not divide the
│ │ │ │  length of the slice, then the last chunk will not have length chunk_size.
      
│ │ │ │ -
      See rchunks_exact_mut for a variant of this iterator that returns chunks of always
│ │ │ │ -exactly chunk_size elements, and chunks_mut for the same iterator but starting at the
│ │ │ │ +
      See rchunks_exact_mut for a variant of this iterator that returns chunks of always
│ │ │ │ +exactly chunk_size elements, and chunks_mut for the same iterator but starting at the
│ │ │ │  beginning of the slice.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if chunk_size is 0.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = &mut [0, 0, 0, 0, 0];
│ │ │ │  let mut count = 1;
│ │ │ │  
│ │ │ │  for chunk in v.rchunks_mut(2) {
│ │ │ │      for elem in chunk.iter_mut() {
│ │ │ │          *elem += count;
│ │ │ │      }
│ │ │ │      count += 1;
│ │ │ │  }
│ │ │ │  assert_eq!(v, &[3, 2, 2, 1, 1]);
      Run
      
│ │ │ │ -
      1.31.0 · source
      pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the
│ │ │ │ +
      1.31.0 · source
      pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the
│ │ │ │  end of the slice.
      
│ │ │ │  
      The chunks are slices and do not overlap. If chunk_size does not divide the length of the
│ │ │ │  slice, then the last up to chunk_size-1 elements will be omitted and can be retrieved
│ │ │ │  from the remainder function of the iterator.
      
│ │ │ │  
      Due to each chunk having exactly chunk_size elements, the compiler can often optimize the
│ │ │ │ -resulting code better than in the case of rchunks.
      
│ │ │ │ -
      See rchunks for a variant of this iterator that also returns the remainder as a smaller
│ │ │ │ -chunk, and chunks_exact for the same iterator but starting at the beginning of the
│ │ │ │ +resulting code better than in the case of rchunks.
      
│ │ │ │ +
      See rchunks for a variant of this iterator that also returns the remainder as a smaller
│ │ │ │ +chunk, and chunks_exact for the same iterator but starting at the beginning of the
│ │ │ │  slice.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if chunk_size is 0.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let slice = ['l', 'o', 'r', 'e', 'm'];
│ │ │ │  let mut iter = slice.rchunks_exact(2);
│ │ │ │  assert_eq!(iter.next().unwrap(), &['e', 'm']);
│ │ │ │  assert_eq!(iter.next().unwrap(), &['o', 'r']);
│ │ │ │  assert!(iter.next().is_none());
│ │ │ │  assert_eq!(iter.remainder(), &['l']);
      Run
      
│ │ │ │ -
      1.31.0 · source
      pub fn rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the end
│ │ │ │ +
      1.31.0 · source
      pub fn rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<'_, T> ⓘ
      Returns an iterator over chunk_size elements of the slice at a time, starting at the end
│ │ │ │  of the slice.
      
│ │ │ │  
      The chunks are mutable slices, and do not overlap. If chunk_size does not divide the
│ │ │ │  length of the slice, then the last up to chunk_size-1 elements will be omitted and can be
│ │ │ │  retrieved from the into_remainder function of the iterator.
      
│ │ │ │  
      Due to each chunk having exactly chunk_size elements, the compiler can often optimize the
│ │ │ │ -resulting code better than in the case of chunks_mut.
      
│ │ │ │ -
      See rchunks_mut for a variant of this iterator that also returns the remainder as a
│ │ │ │ -smaller chunk, and chunks_exact_mut for the same iterator but starting at the beginning
│ │ │ │ +resulting code better than in the case of chunks_mut.
      
│ │ │ │ +
      See rchunks_mut for a variant of this iterator that also returns the remainder as a
│ │ │ │ +smaller chunk, and chunks_exact_mut for the same iterator but starting at the beginning
│ │ │ │  of the slice.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if chunk_size is 0.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = &mut [0, 0, 0, 0, 0];
│ │ │ │  let mut count = 1;
│ │ │ │  
│ │ │ │  for chunk in v.rchunks_exact_mut(2) {
│ │ │ │      for elem in chunk.iter_mut() {
│ │ │ │          *elem += count;
│ │ │ │      }
│ │ │ │      count += 1;
│ │ │ │  }
│ │ │ │  assert_eq!(v, &[0, 2, 2, 1, 1]);
      Run
      
│ │ │ │ -
      1.77.0 · source
      pub fn chunk_by<F>(&self, pred: F) -> ChunkBy<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T, &T) -> bool,
      Returns an iterator over the slice producing non-overlapping runs
│ │ │ │ +
      1.77.0 · source
      pub fn chunk_by<F>(&self, pred: F) -> ChunkBy<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T, &T) -> bool,
      Returns an iterator over the slice producing non-overlapping runs
│ │ │ │  of elements using the predicate to separate them.
      
│ │ │ │  
      The predicate is called for every pair of consecutive elements,
│ │ │ │  meaning that it is called on slice[0] and slice[1],
│ │ │ │  followed by slice[1] and slice[2], and so on.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let slice = &[1, 1, 1, 3, 3, 2, 2, 2];
│ │ │ │  
│ │ │ │ @@ -2288,16 +2288,16 @@
│ │ │ │  
│ │ │ │  let mut iter = slice.chunk_by(|a, b| a <= b);
│ │ │ │  
│ │ │ │  assert_eq!(iter.next(), Some(&[1, 1, 2, 3][..]));
│ │ │ │  assert_eq!(iter.next(), Some(&[2, 3][..]));
│ │ │ │  assert_eq!(iter.next(), Some(&[2, 3, 4][..]));
│ │ │ │  assert_eq!(iter.next(), None);
      Run
      
│ │ │ │ -
      1.77.0 · source
      pub fn chunk_by_mut<F>(&mut self, pred: F) -> ChunkByMut<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T, &T) -> bool,
      Returns an iterator over the slice producing non-overlapping mutable
│ │ │ │ +
      1.77.0 · source
      pub fn chunk_by_mut<F>(&mut self, pred: F) -> ChunkByMut<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T, &T) -> bool,
      Returns an iterator over the slice producing non-overlapping mutable
│ │ │ │  runs of elements using the predicate to separate them.
      
│ │ │ │  
      The predicate is called for every pair of consecutive elements,
│ │ │ │  meaning that it is called on slice[0] and slice[1],
│ │ │ │  followed by slice[1] and slice[2], and so on.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let slice = &mut [1, 1, 1, 3, 3, 2, 2, 2];
│ │ │ │  
│ │ │ │ @@ -2313,21 +2313,21 @@
│ │ │ │  
│ │ │ │  let mut iter = slice.chunk_by_mut(|a, b| a <= b);
│ │ │ │  
│ │ │ │  assert_eq!(iter.next(), Some(&mut [1, 1, 2, 3][..]));
│ │ │ │  assert_eq!(iter.next(), Some(&mut [2, 3][..]));
│ │ │ │  assert_eq!(iter.next(), Some(&mut [2, 3, 4][..]));
│ │ │ │  assert_eq!(iter.next(), None);
      Run
      
│ │ │ │ -
      source
      pub fn split_at(&self, mid: usize) -> (&[T], &[T])
      Divides one slice into two at an index.
      
│ │ │ │ +
      source
      pub fn split_at(&self, mid: usize) -> (&[T], &[T])
      Divides one slice into two at an index.
      
│ │ │ │  
      The first will contain all indices from [0, mid) (excluding
│ │ │ │  the index mid itself) and the second will contain all
│ │ │ │  indices from [mid, len) (excluding the index len itself).
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if mid > len.  For a non-panicking alternative see
│ │ │ │ -split_at_checked.
      
│ │ │ │ +split_at_checked.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = [1, 2, 3, 4, 5, 6];
│ │ │ │  
│ │ │ │  {
│ │ │ │     let (left, right) = v.split_at(0);
│ │ │ │     assert_eq!(left, []);
│ │ │ │     assert_eq!(right, [1, 2, 3, 4, 5, 6]);
│ │ │ │ @@ -2340,34 +2340,34 @@
│ │ │ │  }
│ │ │ │  
│ │ │ │  {
│ │ │ │      let (left, right) = v.split_at(6);
│ │ │ │      assert_eq!(left, [1, 2, 3, 4, 5, 6]);
│ │ │ │      assert_eq!(right, []);
│ │ │ │  }
      Run
      
│ │ │ │ -
      source
      pub fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])
      Divides one mutable slice into two at an index.
      
│ │ │ │ +
      source
      pub fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])
      Divides one mutable slice into two at an index.
      
│ │ │ │  
      The first will contain all indices from [0, mid) (excluding
│ │ │ │  the index mid itself) and the second will contain all
│ │ │ │  indices from [mid, len) (excluding the index len itself).
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics if mid > len.  For a non-panicking alternative see
│ │ │ │ -split_at_mut_checked.
      
│ │ │ │ +split_at_mut_checked.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [1, 0, 3, 0, 5, 6];
│ │ │ │  let (left, right) = v.split_at_mut(2);
│ │ │ │  assert_eq!(left, [1, 0]);
│ │ │ │  assert_eq!(right, [3, 0, 5, 6]);
│ │ │ │  left[1] = 2;
│ │ │ │  right[1] = 4;
│ │ │ │  assert_eq!(v, [1, 2, 3, 4, 5, 6]);
      Run
      
│ │ │ │ -
      source
      pub unsafe fn split_at_unchecked(&self, mid: usize) -> (&[T], &[T])
      🔬This is a nightly-only experimental API. (slice_split_at_unchecked #76014)
      Divides one slice into two at an index, without doing bounds checking.
      
│ │ │ │ +
      source
      pub unsafe fn split_at_unchecked(&self, mid: usize) -> (&[T], &[T])
      🔬This is a nightly-only experimental API. (slice_split_at_unchecked #76014)
      Divides one slice into two at an index, without doing bounds checking.
      
│ │ │ │  
      The first will contain all indices from [0, mid) (excluding
│ │ │ │  the index mid itself) and the second will contain all
│ │ │ │  indices from [mid, len) (excluding the index len itself).
      
│ │ │ │ -
      For a safe alternative see split_at.
      
│ │ │ │ +
      For a safe alternative see split_at.
      
│ │ │ │  
      §Safety
      
│ │ │ │  
      Calling this method with an out-of-bounds index is undefined behavior
│ │ │ │  even if the resulting reference is not used. The caller has to ensure that
│ │ │ │  0 <= mid <= self.len().
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_split_at_unchecked)]
│ │ │ │  
│ │ │ │ @@ -2386,22 +2386,22 @@
│ │ │ │  }
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      let (left, right) = v.split_at_unchecked(6);
│ │ │ │      assert_eq!(left, [1, 2, 3, 4, 5, 6]);
│ │ │ │      assert_eq!(right, []);
│ │ │ │  }
      Run
      
│ │ │ │ -
      source
      pub unsafe fn split_at_mut_unchecked(
│ │ │ │ +
      source
      pub unsafe fn split_at_mut_unchecked(
│ │ │ │      &mut self,
│ │ │ │ -    mid: usize
│ │ │ │ -) -> (&mut [T], &mut [T])
      🔬This is a nightly-only experimental API. (slice_split_at_unchecked #76014)
      Divides one mutable slice into two at an index, without doing bounds checking.
      
│ │ │ │ +    mid: usize
│ │ │ │ +) -> (&mut [T], &mut [T])
      🔬This is a nightly-only experimental API. (slice_split_at_unchecked #76014)
      Divides one mutable slice into two at an index, without doing bounds checking.
      
│ │ │ │  
      The first will contain all indices from [0, mid) (excluding
│ │ │ │  the index mid itself) and the second will contain all
│ │ │ │  indices from [mid, len) (excluding the index len itself).
      
│ │ │ │ -
      For a safe alternative see split_at_mut.
      
│ │ │ │ +
      For a safe alternative see split_at_mut.
      
│ │ │ │  
      §Safety
      
│ │ │ │  
      Calling this method with an out-of-bounds index is undefined behavior
│ │ │ │  even if the resulting reference is not used. The caller has to ensure that
│ │ │ │  0 <= mid <= self.len().
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_split_at_unchecked)]
│ │ │ │  
│ │ │ │ @@ -2411,15 +2411,15 @@
│ │ │ │      let (left, right) = v.split_at_mut_unchecked(2);
│ │ │ │      assert_eq!(left, [1, 0]);
│ │ │ │      assert_eq!(right, [3, 0, 5, 6]);
│ │ │ │      left[1] = 2;
│ │ │ │      right[1] = 4;
│ │ │ │  }
│ │ │ │  assert_eq!(v, [1, 2, 3, 4, 5, 6]);
      Run
      
│ │ │ │ -
      source
      pub fn split_at_checked(&self, mid: usize) -> Option<(&[T], &[T])>
      🔬This is a nightly-only experimental API. (split_at_checked #119128)
      Divides one slice into two at an index, returning None if the slice is
│ │ │ │ +
      source
      pub fn split_at_checked(&self, mid: usize) -> Option<(&[T], &[T])>
      🔬This is a nightly-only experimental API. (split_at_checked #119128)
      Divides one slice into two at an index, returning None if the slice is
│ │ │ │  too short.
      
│ │ │ │  
      If mid ≤ len returns a pair of slices where the first will contain all
│ │ │ │  indices from [0, mid) (excluding the index mid itself) and the
│ │ │ │  second will contain all indices from [mid, len) (excluding the index
│ │ │ │  len itself).
      
│ │ │ │  
      Otherwise, if mid > len, returns None.
      
│ │ │ │  
      §Examples
      
│ │ │ │ @@ -2442,18 +2442,18 @@
│ │ │ │  {
│ │ │ │      let (left, right) = v.split_at_checked(6).unwrap();
│ │ │ │      assert_eq!(left, [1, -2, 3, -4, 5, -6]);
│ │ │ │      assert_eq!(right, []);
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(None, v.split_at_checked(7));Run
      
│ │ │ │ -
      source
      pub fn split_at_mut_checked(
│ │ │ │ +
      source
      pub fn split_at_mut_checked(
│ │ │ │      &mut self,
│ │ │ │ -    mid: usize
│ │ │ │ -) -> Option<(&mut [T], &mut [T])>
      🔬This is a nightly-only experimental API. (split_at_checked #119128)
      Divides one mutable slice into two at an index, returning None if the
│ │ │ │ +    mid: usize
│ │ │ │ +) -> Option<(&mut [T], &mut [T])>
      🔬This is a nightly-only experimental API. (split_at_checked #119128)
      Divides one mutable slice into two at an index, returning None if the
│ │ │ │  slice is too short.
      
│ │ │ │  
      If mid ≤ len returns a pair of slices where the first will contain all
│ │ │ │  indices from [0, mid) (excluding the index mid itself) and the
│ │ │ │  second will contain all indices from [mid, len) (excluding the index
│ │ │ │  len itself).
      
│ │ │ │  
      Otherwise, if mid > len, returns None.
      
│ │ │ │  
      §Examples
      
│ │ │ │ @@ -2466,16 +2466,16 @@
│ │ │ │      assert_eq!(right, [3, 0, 5, 6]);
│ │ │ │      left[1] = 2;
│ │ │ │      right[1] = 4;
│ │ │ │  }
│ │ │ │  assert_eq!(v, [1, 2, 3, 4, 5, 6]);
│ │ │ │  
│ │ │ │  assert_eq!(None, v.split_at_mut_checked(7));Run
      
│ │ │ │ -
      source
      pub fn split<F>(&self, pred: F) -> Split<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │ +
      source
      pub fn split<F>(&self, pred: F) -> Split<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │  pred. The matched element is not contained in the subslices.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let slice = [10, 40, 33, 20];
│ │ │ │  let mut iter = slice.split(|num| num % 3 == 0);
│ │ │ │  
│ │ │ │  assert_eq!(iter.next().unwrap(), &[10, 40]);
│ │ │ │  assert_eq!(iter.next().unwrap(), &[20]);
│ │ │ │ @@ -2497,26 +2497,26 @@
│ │ │ │  
      let slice = [10, 6, 33, 20];
│ │ │ │  let mut iter = slice.split(|num| num % 3 == 0);
│ │ │ │  
│ │ │ │  assert_eq!(iter.next().unwrap(), &[10]);
│ │ │ │  assert_eq!(iter.next().unwrap(), &[]);
│ │ │ │  assert_eq!(iter.next().unwrap(), &[20]);
│ │ │ │  assert!(iter.next().is_none());
      Run
      
│ │ │ │ -
      source
      pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      Returns an iterator over mutable subslices separated by elements that
│ │ │ │ +
      source
      pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      Returns an iterator over mutable subslices separated by elements that
│ │ │ │  match pred. The matched element is not contained in the subslices.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [10, 40, 30, 20, 60, 50];
│ │ │ │  
│ │ │ │  for group in v.split_mut(|num| *num % 3 == 0) {
│ │ │ │      group[0] = 1;
│ │ │ │  }
│ │ │ │  assert_eq!(v, [1, 40, 30, 1, 60, 1]);
      Run
      
│ │ │ │ -
      1.51.0 · source
      pub fn split_inclusive<F>(&self, pred: F) -> SplitInclusive<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │ +
      1.51.0 · source
      pub fn split_inclusive<F>(&self, pred: F) -> SplitInclusive<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │  pred. The matched element is contained in the end of the previous
│ │ │ │  subslice as a terminator.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let slice = [10, 40, 33, 20];
│ │ │ │  let mut iter = slice.split_inclusive(|num| num % 3 == 0);
│ │ │ │  
│ │ │ │  assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
│ │ │ │ @@ -2528,28 +2528,28 @@
│ │ │ │  
│ │ │ │  
      let slice = [3, 10, 40, 33];
│ │ │ │  let mut iter = slice.split_inclusive(|num| num % 3 == 0);
│ │ │ │  
│ │ │ │  assert_eq!(iter.next().unwrap(), &[3]);
│ │ │ │  assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
│ │ │ │  assert!(iter.next().is_none());
      Run
      
│ │ │ │ -
      1.51.0 · source
      pub fn split_inclusive_mut<F>(&mut self, pred: F) -> SplitInclusiveMut<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      Returns an iterator over mutable subslices separated by elements that
│ │ │ │ +
      1.51.0 · source
      pub fn split_inclusive_mut<F>(&mut self, pred: F) -> SplitInclusiveMut<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      Returns an iterator over mutable subslices separated by elements that
│ │ │ │  match pred. The matched element is contained in the previous
│ │ │ │  subslice as a terminator.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [10, 40, 30, 20, 60, 50];
│ │ │ │  
│ │ │ │  for group in v.split_inclusive_mut(|num| *num % 3 == 0) {
│ │ │ │      let terminator_idx = group.len()-1;
│ │ │ │      group[terminator_idx] = 1;
│ │ │ │  }
│ │ │ │  assert_eq!(v, [10, 40, 1, 20, 1, 1]);
      Run
      
│ │ │ │ -
      1.27.0 · source
      pub fn rsplit<F>(&self, pred: F) -> RSplit<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │ +
      1.27.0 · source
      pub fn rsplit<F>(&self, pred: F) -> RSplit<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │  pred, starting at the end of the slice and working backwards.
│ │ │ │  The matched element is not contained in the subslices.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let slice = [11, 22, 33, 0, 44, 55];
│ │ │ │  let mut iter = slice.rsplit(|num| *num == 0);
│ │ │ │  
│ │ │ │  assert_eq!(iter.next().unwrap(), &[44, 55]);
│ │ │ │ @@ -2561,161 +2561,161 @@
│ │ │ │  
      let v = &[0, 1, 1, 2, 3, 5, 8];
│ │ │ │  let mut it = v.rsplit(|n| *n % 2 == 0);
│ │ │ │  assert_eq!(it.next().unwrap(), &[]);
│ │ │ │  assert_eq!(it.next().unwrap(), &[3, 5]);
│ │ │ │  assert_eq!(it.next().unwrap(), &[1, 1]);
│ │ │ │  assert_eq!(it.next().unwrap(), &[]);
│ │ │ │  assert_eq!(it.next(), None);
      Run
      
│ │ │ │ -
      1.27.0 · source
      pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      Returns an iterator over mutable subslices separated by elements that
│ │ │ │ +
      1.27.0 · source
      pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      Returns an iterator over mutable subslices separated by elements that
│ │ │ │  match pred, starting at the end of the slice and working
│ │ │ │  backwards. The matched element is not contained in the subslices.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [100, 400, 300, 200, 600, 500];
│ │ │ │  
│ │ │ │  let mut count = 0;
│ │ │ │  for group in v.rsplit_mut(|num| *num % 3 == 0) {
│ │ │ │      count += 1;
│ │ │ │      group[0] = count;
│ │ │ │  }
│ │ │ │  assert_eq!(v, [3, 400, 300, 2, 600, 1]);
      Run
      
│ │ │ │ -
      source
      pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │ +
      source
      pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │  pred, limited to returning at most n items. The matched element is
│ │ │ │  not contained in the subslices.
      
│ │ │ │  
      The last element returned, if any, will contain the remainder of the
│ │ │ │  slice.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      Print the slice split once by numbers divisible by 3 (i.e., [10, 40],
│ │ │ │  [20, 60, 50]):
      
│ │ │ │  
│ │ │ │  
      let v = [10, 40, 30, 20, 60, 50];
│ │ │ │  
│ │ │ │  for group in v.splitn(2, |num| *num % 3 == 0) {
│ │ │ │      println!("{group:?}");
│ │ │ │  }
      Run
      
│ │ │ │ -
      source
      pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      Returns an iterator over mutable subslices separated by elements that match
│ │ │ │ +
      source
      pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      Returns an iterator over mutable subslices separated by elements that match
│ │ │ │  pred, limited to returning at most n items. The matched element is
│ │ │ │  not contained in the subslices.
      
│ │ │ │  
      The last element returned, if any, will contain the remainder of the
│ │ │ │  slice.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [10, 40, 30, 20, 60, 50];
│ │ │ │  
│ │ │ │  for group in v.splitn_mut(2, |num| *num % 3 == 0) {
│ │ │ │      group[0] = 1;
│ │ │ │  }
│ │ │ │  assert_eq!(v, [1, 40, 30, 1, 60, 50]);
      Run
      
│ │ │ │ -
      source
      pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │ +
      source
      pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │  pred limited to returning at most n items. This starts at the end of
│ │ │ │  the slice and works backwards. The matched element is not contained in
│ │ │ │  the subslices.
      
│ │ │ │  
      The last element returned, if any, will contain the remainder of the
│ │ │ │  slice.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      Print the slice split once, starting from the end, by numbers divisible
│ │ │ │  by 3 (i.e., [50], [10, 40, 30, 20]):
      
│ │ │ │  
│ │ │ │  
      let v = [10, 40, 30, 20, 60, 50];
│ │ │ │  
│ │ │ │  for group in v.rsplitn(2, |num| *num % 3 == 0) {
│ │ │ │      println!("{group:?}");
│ │ │ │  }
      Run
      
│ │ │ │ -
      source
      pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<'_, T, F> ⓘ
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │ +
      source
      pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<'_, T, F> ⓘ
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      Returns an iterator over subslices separated by elements that match
│ │ │ │  pred limited to returning at most n items. This starts at the end of
│ │ │ │  the slice and works backwards. The matched element is not contained in
│ │ │ │  the subslices.
      
│ │ │ │  
      The last element returned, if any, will contain the remainder of the
│ │ │ │  slice.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut s = [10, 40, 30, 20, 60, 50];
│ │ │ │  
│ │ │ │  for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {
│ │ │ │      group[0] = 1;
│ │ │ │  }
│ │ │ │  assert_eq!(s, [1, 40, 30, 20, 60, 1]);
      Run
      
│ │ │ │ -
      source
      pub fn split_once<F>(&self, pred: F) -> Option<(&[T], &[T])>
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      🔬This is a nightly-only experimental API. (slice_split_once #112811)
      Splits the slice on the first element that matches the specified
│ │ │ │ +
      source
      pub fn split_once<F>(&self, pred: F) -> Option<(&[T], &[T])>
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      🔬This is a nightly-only experimental API. (slice_split_once #112811)
      Splits the slice on the first element that matches the specified
│ │ │ │  predicate.
      
│ │ │ │  
      If any matching elements are present in the slice, returns the prefix
│ │ │ │  before the match and suffix after. The matching element itself is not
│ │ │ │  included. If no elements match, returns None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_split_once)]
│ │ │ │  let s = [1, 2, 3, 2, 4];
│ │ │ │  assert_eq!(s.split_once(|&x| x == 2), Some((
│ │ │ │      &[1][..],
│ │ │ │      &[3, 2, 4][..]
│ │ │ │  )));
│ │ │ │  assert_eq!(s.split_once(|&x| x == 0), None);
      Run
      
│ │ │ │ -
      source
      pub fn rsplit_once<F>(&self, pred: F) -> Option<(&[T], &[T])>
      where
│ │ │ │ -    F: FnMut(&T) -> bool,
      🔬This is a nightly-only experimental API. (slice_split_once #112811)
      Splits the slice on the last element that matches the specified
│ │ │ │ +
      source
      pub fn rsplit_once<F>(&self, pred: F) -> Option<(&[T], &[T])>
      where
│ │ │ │ +    F: FnMut(&T) -> bool,
      🔬This is a nightly-only experimental API. (slice_split_once #112811)
      Splits the slice on the last element that matches the specified
│ │ │ │  predicate.
      
│ │ │ │  
      If any matching elements are present in the slice, returns the prefix
│ │ │ │  before the match and suffix after. The matching element itself is not
│ │ │ │  included. If no elements match, returns None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_split_once)]
│ │ │ │  let s = [1, 2, 3, 2, 4];
│ │ │ │  assert_eq!(s.rsplit_once(|&x| x == 2), Some((
│ │ │ │      &[1, 2, 3][..],
│ │ │ │      &[4][..]
│ │ │ │  )));
│ │ │ │  assert_eq!(s.rsplit_once(|&x| x == 0), None);
      Run
      
│ │ │ │ -
      source
      pub fn contains(&self, x: &T) -> bool
      where
│ │ │ │ -    T: PartialEq,
      Returns true if the slice contains an element with the given value.
      
│ │ │ │ +
      source
      pub fn contains(&self, x: &T) -> bool
      where
│ │ │ │ +    T: PartialEq,
      Returns true if the slice contains an element with the given value.
      
│ │ │ │  
      This operation is O(n).
      
│ │ │ │ -
      Note that if you have a sorted slice, binary_search may be faster.
      
│ │ │ │ +
      Note that if you have a sorted slice, binary_search may be faster.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = [10, 40, 30];
│ │ │ │  assert!(v.contains(&30));
│ │ │ │  assert!(!v.contains(&50));
      Run
      
│ │ │ │  
      If you do not have a &T, but some other value that you can compare
│ │ │ │  with one (for example, String implements PartialEq<str>), you can
│ │ │ │  use iter().any:
      
│ │ │ │  
│ │ │ │  
      let v = [String::from("hello"), String::from("world")]; // slice of `String`
│ │ │ │  assert!(v.iter().any(|e| e == "hello")); // search with `&str`
│ │ │ │  assert!(!v.iter().any(|e| e == "hi"));
      Run
      
│ │ │ │ -
      source
      pub fn starts_with(&self, needle: &[T]) -> bool
      where
│ │ │ │ -    T: PartialEq,
      Returns true if needle is a prefix of the slice or equal to the slice.
      
│ │ │ │ +
      source
      pub fn starts_with(&self, needle: &[T]) -> bool
      where
│ │ │ │ +    T: PartialEq,
      Returns true if needle is a prefix of the slice or equal to the slice.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = [10, 40, 30];
│ │ │ │  assert!(v.starts_with(&[10]));
│ │ │ │  assert!(v.starts_with(&[10, 40]));
│ │ │ │  assert!(v.starts_with(&v));
│ │ │ │  assert!(!v.starts_with(&[50]));
│ │ │ │  assert!(!v.starts_with(&[10, 50]));
      Run
      
│ │ │ │  
      Always returns true if needle is an empty slice:
      
│ │ │ │  
│ │ │ │  
      let v = &[10, 40, 30];
│ │ │ │  assert!(v.starts_with(&[]));
│ │ │ │  let v: &[u8] = &[];
│ │ │ │  assert!(v.starts_with(&[]));
      Run
      
│ │ │ │ -
      source
      pub fn ends_with(&self, needle: &[T]) -> bool
      where
│ │ │ │ -    T: PartialEq,
      Returns true if needle is a suffix of the slice or equal to the slice.
      
│ │ │ │ +
      source
      pub fn ends_with(&self, needle: &[T]) -> bool
      where
│ │ │ │ +    T: PartialEq,
      Returns true if needle is a suffix of the slice or equal to the slice.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = [10, 40, 30];
│ │ │ │  assert!(v.ends_with(&[30]));
│ │ │ │  assert!(v.ends_with(&[40, 30]));
│ │ │ │  assert!(v.ends_with(&v));
│ │ │ │  assert!(!v.ends_with(&[50]));
│ │ │ │  assert!(!v.ends_with(&[50, 30]));
      Run
      
│ │ │ │  
      Always returns true if needle is an empty slice:
      
│ │ │ │  
│ │ │ │  
      let v = &[10, 40, 30];
│ │ │ │  assert!(v.ends_with(&[]));
│ │ │ │  let v: &[u8] = &[];
│ │ │ │  assert!(v.ends_with(&[]));
      Run
      
│ │ │ │ -
      1.51.0 · source
      pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>
      where
│ │ │ │ -    P: SlicePattern<Item = T> + ?Sized,
│ │ │ │ -    T: PartialEq,
      Returns a subslice with the prefix removed.
      
│ │ │ │ +
      1.51.0 · source
      pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>
      where
│ │ │ │ +    P: SlicePattern<Item = T> + ?Sized,
│ │ │ │ +    T: PartialEq,
      Returns a subslice with the prefix removed.
      
│ │ │ │  
      If the slice starts with prefix, returns the subslice after the prefix, wrapped in Some.
│ │ │ │  If prefix is empty, simply returns the original slice. If prefix is equal to the
│ │ │ │  original slice, returns an empty slice.
      
│ │ │ │  
      If the slice does not start with prefix, returns None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = &[10, 40, 30];
│ │ │ │  assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
│ │ │ │ @@ -2723,54 +2723,54 @@
│ │ │ │  assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
│ │ │ │  assert_eq!(v.strip_prefix(&[50]), None);
│ │ │ │  assert_eq!(v.strip_prefix(&[10, 50]), None);
│ │ │ │  
│ │ │ │  let prefix : &str = "he";
│ │ │ │  assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
│ │ │ │             Some(b"llo".as_ref()));
      Run
      
│ │ │ │ -
      1.51.0 · source
      pub fn strip_suffix<P>(&self, suffix: &P) -> Option<&[T]>
      where
│ │ │ │ -    P: SlicePattern<Item = T> + ?Sized,
│ │ │ │ -    T: PartialEq,
      Returns a subslice with the suffix removed.
      
│ │ │ │ +
      1.51.0 · source
      pub fn strip_suffix<P>(&self, suffix: &P) -> Option<&[T]>
      where
│ │ │ │ +    P: SlicePattern<Item = T> + ?Sized,
│ │ │ │ +    T: PartialEq,
      Returns a subslice with the suffix removed.
      
│ │ │ │  
      If the slice ends with suffix, returns the subslice before the suffix, wrapped in Some.
│ │ │ │  If suffix is empty, simply returns the original slice. If suffix is equal to the
│ │ │ │  original slice, returns an empty slice.
      
│ │ │ │  
      If the slice does not end with suffix, returns None.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = &[10, 40, 30];
│ │ │ │  assert_eq!(v.strip_suffix(&[30]), Some(&[10, 40][..]));
│ │ │ │  assert_eq!(v.strip_suffix(&[40, 30]), Some(&[10][..]));
│ │ │ │  assert_eq!(v.strip_suffix(&[10, 40, 30]), Some(&[][..]));
│ │ │ │  assert_eq!(v.strip_suffix(&[50]), None);
│ │ │ │  assert_eq!(v.strip_suffix(&[50, 30]), None);
      Run
      
│ │ │ │ -
      Binary searches this slice for a given element.
│ │ │ │ +
      Binary searches this slice for a given element.
│ │ │ │  If the slice is not sorted, the returned result is unspecified and
│ │ │ │  meaningless.
      
│ │ │ │ -
      If the value is found then Result::Ok is returned, containing the
│ │ │ │ +
      If the value is found then Result::Ok is returned, containing the
│ │ │ │  index of the matching element. If there are multiple matches, then any
│ │ │ │  one of the matches could be returned. The index is chosen
│ │ │ │  deterministically, but is subject to change in future versions of Rust.
│ │ │ │ -If the value is not found then Result::Err is returned, containing
│ │ │ │ +If the value is not found then Result::Err is returned, containing
│ │ │ │  the index where a matching element could be inserted while maintaining
│ │ │ │  sorted order.
      
│ │ │ │ -
      See also binary_search_by, binary_search_by_key, and partition_point.
      
│ │ │ │ +
      See also binary_search_by, binary_search_by_key, and partition_point.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      Looks up a series of four elements. The first is found, with a
│ │ │ │  uniquely determined position; the second and third are not
│ │ │ │  found; the fourth could match any position in [1, 4].
      
│ │ │ │  
│ │ │ │  
      let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
│ │ │ │  
│ │ │ │  assert_eq!(s.binary_search(&13),  Ok(9));
│ │ │ │  assert_eq!(s.binary_search(&4),   Err(7));
│ │ │ │  assert_eq!(s.binary_search(&100), Err(13));
│ │ │ │  let r = s.binary_search(&1);
│ │ │ │  assert!(match r { Ok(1..=4) => true, _ => false, });
      Run
      
│ │ │ │  
      If you want to find that whole range of matching items, rather than
│ │ │ │ -an arbitrary matching one, that can be done using partition_point:
      
│ │ │ │ +an arbitrary matching one, that can be done using partition_point:
      
│ │ │ │  
│ │ │ │  
      let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
│ │ │ │  
│ │ │ │  let low = s.partition_point(|x| x < &1);
│ │ │ │  assert_eq!(low, 1);
│ │ │ │  let high = s.partition_point(|x| x <= &1);
│ │ │ │  assert_eq!(high, 5);
│ │ │ │ @@ -2782,38 +2782,38 @@
│ │ │ │  assert!(s[high..].iter().all(|&x| x > 1));
│ │ │ │  
│ │ │ │  // For something not found, the "range" of equal items is empty
│ │ │ │  assert_eq!(s.partition_point(|x| x < &11), 9);
│ │ │ │  assert_eq!(s.partition_point(|x| x <= &11), 9);
│ │ │ │  assert_eq!(s.binary_search(&11), Err(9));
      Run
      
│ │ │ │  
      If you want to insert an item to a sorted vector, while maintaining
│ │ │ │ -sort order, consider using partition_point:
      
│ │ │ │ +sort order, consider using partition_point:
      
│ │ │ │  
│ │ │ │  
      let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
│ │ │ │  let num = 42;
│ │ │ │  let idx = s.partition_point(|&x| x < num);
│ │ │ │  // The above is equivalent to `let idx = s.binary_search(&num).unwrap_or_else(|x| x);`
│ │ │ │  s.insert(idx, num);
│ │ │ │  assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
      Run
      
│ │ │ │ -
      source
      pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
      where
│ │ │ │ -    F: FnMut(&'a T) -> Ordering,
      Binary searches this slice with a comparator function.
      
│ │ │ │ +
      source
      pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
      where
│ │ │ │ +    F: FnMut(&'a T) -> Ordering,
      Binary searches this slice with a comparator function.
      
│ │ │ │  
      The comparator function should return an order code that indicates
│ │ │ │  whether its argument is Less, Equal or Greater the desired
│ │ │ │  target.
│ │ │ │  If the slice is not sorted or if the comparator function does not
│ │ │ │  implement an order consistent with the sort order of the underlying
│ │ │ │  slice, the returned result is unspecified and meaningless.
      
│ │ │ │ -
      If the value is found then Result::Ok is returned, containing the
│ │ │ │ +
      If the value is found then Result::Ok is returned, containing the
│ │ │ │  index of the matching element. If there are multiple matches, then any
│ │ │ │  one of the matches could be returned. The index is chosen
│ │ │ │  deterministically, but is subject to change in future versions of Rust.
│ │ │ │ -If the value is not found then Result::Err is returned, containing
│ │ │ │ +If the value is not found then Result::Err is returned, containing
│ │ │ │  the index where a matching element could be inserted while maintaining
│ │ │ │  sorted order.
      
│ │ │ │ -
      See also binary_search, binary_search_by_key, and partition_point.
      
│ │ │ │ +
      See also binary_search, binary_search_by_key, and partition_point.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      Looks up a series of four elements. The first is found, with a
│ │ │ │  uniquely determined position; the second and third are not
│ │ │ │  found; the fourth could match any position in [1, 4].
      
│ │ │ │  
│ │ │ │  
      let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
│ │ │ │  
│ │ │ │ @@ -2822,33 +2822,33 @@
│ │ │ │  let seek = 4;
│ │ │ │  assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7));
│ │ │ │  let seek = 100;
│ │ │ │  assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13));
│ │ │ │  let seek = 1;
│ │ │ │  let r = s.binary_search_by(|probe| probe.cmp(&seek));
│ │ │ │  assert!(match r { Ok(1..=4) => true, _ => false, });
      Run
      
│ │ │ │ -
      1.10.0 · source
      pub fn binary_search_by_key<'a, B, F>(
│ │ │ │ +
      1.10.0 · source
      pub fn binary_search_by_key<'a, B, F>(
│ │ │ │      &'a self,
│ │ │ │ -    b: &B,
│ │ │ │ +    b: &B,
│ │ │ │      f: F
│ │ │ │ -) -> Result<usize, usize>
      where
│ │ │ │ -    F: FnMut(&'a T) -> B,
│ │ │ │ -    B: Ord,
      Binary searches this slice with a key extraction function.
      
│ │ │ │ +) -> Result<usize, usize>
      where
│ │ │ │ +    F: FnMut(&'a T) -> B,
│ │ │ │ +    B: Ord,
      Binary searches this slice with a key extraction function.
      
│ │ │ │  
      Assumes that the slice is sorted by the key, for instance with
│ │ │ │ -sort_by_key using the same key extraction function.
│ │ │ │ +sort_by_key using the same key extraction function.
│ │ │ │  If the slice is not sorted by the key, the returned result is
│ │ │ │  unspecified and meaningless.
      
│ │ │ │ -
      If the value is found then Result::Ok is returned, containing the
│ │ │ │ +
      If the value is found then Result::Ok is returned, containing the
│ │ │ │  index of the matching element. If there are multiple matches, then any
│ │ │ │  one of the matches could be returned. The index is chosen
│ │ │ │  deterministically, but is subject to change in future versions of Rust.
│ │ │ │ -If the value is not found then Result::Err is returned, containing
│ │ │ │ +If the value is not found then Result::Err is returned, containing
│ │ │ │  the index where a matching element could be inserted while maintaining
│ │ │ │  sorted order.
      
│ │ │ │ -
      See also binary_search, binary_search_by, and partition_point.
      
│ │ │ │ +
      See also binary_search, binary_search_by, and partition_point.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      Looks up a series of four elements in a slice of pairs sorted by
│ │ │ │  their second elements. The first is found, with a uniquely
│ │ │ │  determined position; the second and third are not found; the
│ │ │ │  fourth could match any position in [1, 4].
      
│ │ │ │  
│ │ │ │  
      let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
│ │ │ │ @@ -2856,16 +2856,16 @@
│ │ │ │           (1, 21), (2, 34), (4, 55)];
│ │ │ │  
│ │ │ │  assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
│ │ │ │  assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
│ │ │ │  assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13));
│ │ │ │  let r = s.binary_search_by_key(&1, |&(a, b)| b);
│ │ │ │  assert!(match r { Ok(1..=4) => true, _ => false, });
      Run
      
│ │ │ │ -
      1.20.0 · source
      pub fn sort_unstable(&mut self)
      where
│ │ │ │ -    T: Ord,
      Sorts the slice, but might not preserve the order of equal elements.
      
│ │ │ │ +
      1.20.0 · source
      pub fn sort_unstable(&mut self)
      where
│ │ │ │ +    T: Ord,
      Sorts the slice, but might not preserve the order of equal elements.
      
│ │ │ │  
      This sort is unstable (i.e., may reorder equal elements), in-place
│ │ │ │  (i.e., does not allocate), and O(n * log(n)) worst-case.
      
│ │ │ │  
      §Current implementation
      
│ │ │ │  
      The current algorithm is based on pattern-defeating quicksort by Orson Peters,
│ │ │ │  which combines the fast average case of randomized quicksort with the fast worst case of
│ │ │ │  heapsort, while achieving linear time on slices with certain patterns. It uses some
│ │ │ │  randomization to avoid degenerate cases, but with a fixed seed to always provide
│ │ │ │ @@ -2873,27 +2873,27 @@
│ │ │ │  
      It is typically faster than stable sorting, except in a few special cases, e.g., when the
│ │ │ │  slice consists of several concatenated sorted sequences.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [-5, 4, 1, -3, 2];
│ │ │ │  
│ │ │ │  v.sort_unstable();
│ │ │ │  assert!(v == [-5, -3, 1, 2, 4]);
      Run
      
│ │ │ │ -
      1.20.0 · source
      pub fn sort_unstable_by<F>(&mut self, compare: F)
      where
│ │ │ │ -    F: FnMut(&T, &T) -> Ordering,
      Sorts the slice with a comparator function, but might not preserve the order of equal
│ │ │ │ +
      1.20.0 · source
      pub fn sort_unstable_by<F>(&mut self, compare: F)
      where
│ │ │ │ +    F: FnMut(&T, &T) -> Ordering,
      Sorts the slice with a comparator function, but might not preserve the order of equal
│ │ │ │  elements.
      
│ │ │ │  
      This sort is unstable (i.e., may reorder equal elements), in-place
│ │ │ │  (i.e., does not allocate), and O(n * log(n)) worst-case.
      
│ │ │ │  
      The comparator function must define a total ordering for the elements in the slice. If
│ │ │ │  the ordering is not total, the order of the elements is unspecified. An order is a
│ │ │ │  total order if it is (for all a, b and c):
      
│ │ │ │  
        
│ │ │ │  
      • total and antisymmetric: exactly one of a < b, a == b or a > b is true, and
        • 
│ │ │ │  
      • transitive, a < b and b < c implies a < c. The same must hold for both == and >.
        • 
│ │ │ │  
      
│ │ │ │ -
      For example, while f64 doesn’t implement Ord because NaN != NaN, we can use
│ │ │ │ +
      For example, while f64 doesn’t implement Ord because NaN != NaN, we can use
│ │ │ │  partial_cmp as our sort function when we know the slice doesn’t contain a NaN.
      
│ │ │ │  
│ │ │ │  
      let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
│ │ │ │  floats.sort_unstable_by(|a, b| a.partial_cmp(b).unwrap());
│ │ │ │  assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
      Run
      
│ │ │ │  
      §Current implementation
      
│ │ │ │  
      The current algorithm is based on pattern-defeating quicksort by Orson Peters,
│ │ │ │ @@ -2907,17 +2907,17 @@
│ │ │ │  
      let mut v = [5, 4, 1, 3, 2];
│ │ │ │  v.sort_unstable_by(|a, b| a.cmp(b));
│ │ │ │  assert!(v == [1, 2, 3, 4, 5]);
│ │ │ │  
│ │ │ │  // reverse sorting
│ │ │ │  v.sort_unstable_by(|a, b| b.cmp(a));
│ │ │ │  assert!(v == [5, 4, 3, 2, 1]);
      Run
      
│ │ │ │ -
      1.20.0 · source
      pub fn sort_unstable_by_key<K, F>(&mut self, f: F)
      where
│ │ │ │ -    F: FnMut(&T) -> K,
│ │ │ │ -    K: Ord,
      Sorts the slice with a key extraction function, but might not preserve the order of equal
│ │ │ │ +
      1.20.0 · source
      pub fn sort_unstable_by_key<K, F>(&mut self, f: F)
      where
│ │ │ │ +    F: FnMut(&T) -> K,
│ │ │ │ +    K: Ord,
      Sorts the slice with a key extraction function, but might not preserve the order of equal
│ │ │ │  elements.
      
│ │ │ │  
      This sort is unstable (i.e., may reorder equal elements), in-place
│ │ │ │  (i.e., does not allocate), and O(m * n * log(n)) worst-case, where the key function is
│ │ │ │  O(m).
      
│ │ │ │  
      §Current implementation
      
│ │ │ │  
      The current algorithm is based on pattern-defeating quicksort by Orson Peters,
│ │ │ │  which combines the fast average case of randomized quicksort with the fast worst case of
│ │ │ │ @@ -2928,31 +2928,31 @@
│ │ │ │  is likely to be slower than sort_by_cached_key in
│ │ │ │  cases where the key function is expensive.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [-5i32, 4, 1, -3, 2];
│ │ │ │  
│ │ │ │  v.sort_unstable_by_key(|k| k.abs());
│ │ │ │  assert!(v == [1, 2, -3, 4, -5]);
      Run
      
│ │ │ │ -
      1.49.0 · source
      pub fn select_nth_unstable(
│ │ │ │ +
      1.49.0 · source
      pub fn select_nth_unstable(
│ │ │ │      &mut self,
│ │ │ │ -    index: usize
│ │ │ │ -) -> (&mut [T], &mut T, &mut [T])
      where
│ │ │ │ -    T: Ord,
      Reorder the slice such that the element at index after the reordering is at its final sorted position.
      
│ │ │ │ +    index: usize
│ │ │ │ +) -> (&mut [T], &mut T, &mut [T])
      where
│ │ │ │ +    T: Ord,
      Reorder the slice such that the element at index after the reordering is at its final sorted position.
      
│ │ │ │  
      This reordering has the additional property that any value at position i < index will be
│ │ │ │  less than or equal to any value at a position j > index. Additionally, this reordering is
│ │ │ │  unstable (i.e. any number of equal elements may end up at position index), in-place
│ │ │ │  (i.e. does not allocate), and runs in O(n) time.
│ │ │ │  This function is also known as “kth element” in other libraries.
      
│ │ │ │  
      It returns a triplet of the following from the reordered slice:
│ │ │ │  the subslice prior to index, the element at index, and the subslice after index;
│ │ │ │  accordingly, the values in those two subslices will respectively all be less-than-or-equal-to
│ │ │ │  and greater-than-or-equal-to the value of the element at index.
      
│ │ │ │  
      §Current implementation
      
│ │ │ │  
      The current algorithm is an introselect implementation based on Pattern Defeating Quicksort, which is also
│ │ │ │ -the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for
│ │ │ │ +the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for
│ │ │ │  pivot selection, which guarantees linear runtime for all inputs.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics when index >= len(), meaning it always panics on empty slices.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [-5i32, 4, 2, -3, 1];
│ │ │ │  
│ │ │ │  // Find the items less than or equal to the median, the median, and greater than or equal to
│ │ │ │ @@ -2965,34 +2965,34 @@
│ │ │ │  
│ │ │ │  // We are only guaranteed the slice will be one of the following, based on the way we sort
│ │ │ │  // about the specified index.
│ │ │ │  assert!(v == [-3, -5, 1, 2, 4] ||
│ │ │ │          v == [-5, -3, 1, 2, 4] ||
│ │ │ │          v == [-3, -5, 1, 4, 2] ||
│ │ │ │          v == [-5, -3, 1, 4, 2]);
      Run
      
│ │ │ │ -
      1.49.0 · source
      pub fn select_nth_unstable_by<F>(
│ │ │ │ +
      1.49.0 · source
      pub fn select_nth_unstable_by<F>(
│ │ │ │      &mut self,
│ │ │ │ -    index: usize,
│ │ │ │ +    index: usize,
│ │ │ │      compare: F
│ │ │ │ -) -> (&mut [T], &mut T, &mut [T])
      where
│ │ │ │ -    F: FnMut(&T, &T) -> Ordering,
      Reorder the slice with a comparator function such that the element at index after the reordering is at
│ │ │ │ +) -> (&mut [T], &mut T, &mut [T])
      where
│ │ │ │ +    F: FnMut(&T, &T) -> Ordering,
      Reorder the slice with a comparator function such that the element at index after the reordering is at
│ │ │ │  its final sorted position.
      
│ │ │ │  
      This reordering has the additional property that any value at position i < index will be
│ │ │ │  less than or equal to any value at a position j > index using the comparator function.
│ │ │ │  Additionally, this reordering is unstable (i.e. any number of equal elements may end up at
│ │ │ │  position index), in-place (i.e. does not allocate), and runs in O(n) time.
│ │ │ │  This function is also known as “kth element” in other libraries.
      
│ │ │ │  
      It returns a triplet of the following from
│ │ │ │  the slice reordered according to the provided comparator function: the subslice prior to
│ │ │ │  index, the element at index, and the subslice after index; accordingly, the values in
│ │ │ │  those two subslices will respectively all be less-than-or-equal-to and greater-than-or-equal-to
│ │ │ │  the value of the element at index.
      
│ │ │ │  
      §Current implementation
      
│ │ │ │  
      The current algorithm is an introselect implementation based on Pattern Defeating Quicksort, which is also
│ │ │ │ -the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for
│ │ │ │ +the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for
│ │ │ │  pivot selection, which guarantees linear runtime for all inputs.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics when index >= len(), meaning it always panics on empty slices.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [-5i32, 4, 2, -3, 1];
│ │ │ │  
│ │ │ │  // Find the items less than or equal to the median, the median, and greater than or equal to
│ │ │ │ @@ -3005,35 +3005,35 @@
│ │ │ │  
│ │ │ │  // We are only guaranteed the slice will be one of the following, based on the way we sort
│ │ │ │  // about the specified index.
│ │ │ │  assert!(v == [2, 4, 1, -5, -3] ||
│ │ │ │          v == [2, 4, 1, -3, -5] ||
│ │ │ │          v == [4, 2, 1, -5, -3] ||
│ │ │ │          v == [4, 2, 1, -3, -5]);
      Run
      
│ │ │ │ -
      1.49.0 · source
      pub fn select_nth_unstable_by_key<K, F>(
│ │ │ │ +
      1.49.0 · source
      pub fn select_nth_unstable_by_key<K, F>(
│ │ │ │      &mut self,
│ │ │ │ -    index: usize,
│ │ │ │ +    index: usize,
│ │ │ │      f: F
│ │ │ │ -) -> (&mut [T], &mut T, &mut [T])
      where
│ │ │ │ -    F: FnMut(&T) -> K,
│ │ │ │ -    K: Ord,
      Reorder the slice with a key extraction function such that the element at index after the reordering is
│ │ │ │ +) -> (&mut [T], &mut T, &mut [T])
      where
│ │ │ │ +    F: FnMut(&T) -> K,
│ │ │ │ +    K: Ord,
      Reorder the slice with a key extraction function such that the element at index after the reordering is
│ │ │ │  at its final sorted position.
      
│ │ │ │  
      This reordering has the additional property that any value at position i < index will be
│ │ │ │  less than or equal to any value at a position j > index using the key extraction function.
│ │ │ │  Additionally, this reordering is unstable (i.e. any number of equal elements may end up at
│ │ │ │  position index), in-place (i.e. does not allocate), and runs in O(n) time.
│ │ │ │  This function is also known as “kth element” in other libraries.
      
│ │ │ │  
      It returns a triplet of the following from
│ │ │ │  the slice reordered according to the provided key extraction function: the subslice prior to
│ │ │ │  index, the element at index, and the subslice after index; accordingly, the values in
│ │ │ │  those two subslices will respectively all be less-than-or-equal-to and greater-than-or-equal-to
│ │ │ │  the value of the element at index.
      
│ │ │ │  
      §Current implementation
      
│ │ │ │  
      The current algorithm is an introselect implementation based on Pattern Defeating Quicksort, which is also
│ │ │ │ -the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for
│ │ │ │ +the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for
│ │ │ │  pivot selection, which guarantees linear runtime for all inputs.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      Panics when index >= len(), meaning it always panics on empty slices.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut v = [-5i32, 4, 1, -3, 2];
│ │ │ │  
│ │ │ │  // Find the items less than or equal to the median, the median, and greater than or equal to
│ │ │ │ @@ -3046,31 +3046,31 @@
│ │ │ │  
│ │ │ │  // We are only guaranteed the slice will be one of the following, based on the way we sort
│ │ │ │  // about the specified index.
│ │ │ │  assert!(v == [1, 2, -3, 4, -5] ||
│ │ │ │          v == [1, 2, -3, -5, 4] ||
│ │ │ │          v == [2, 1, -3, 4, -5] ||
│ │ │ │          v == [2, 1, -3, -5, 4]);
      Run
      
│ │ │ │ -
      source
      pub fn partition_dedup(&mut self) -> (&mut [T], &mut [T])
      where
│ │ │ │ -    T: PartialEq,
      🔬This is a nightly-only experimental API. (slice_partition_dedup #54279)
      Moves all consecutive repeated elements to the end of the slice according to the
│ │ │ │ -PartialEq trait implementation.
      
│ │ │ │ +
      source
      pub fn partition_dedup(&mut self) -> (&mut [T], &mut [T])
      where
│ │ │ │ +    T: PartialEq,
      🔬This is a nightly-only experimental API. (slice_partition_dedup #54279)
      Moves all consecutive repeated elements to the end of the slice according to the
│ │ │ │ +PartialEq trait implementation.
      
│ │ │ │  
      Returns two slices. The first contains no consecutive repeated elements.
│ │ │ │  The second contains all the duplicates in no specified order.
      
│ │ │ │  
      If the slice is sorted, the first returned slice contains no duplicates.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_partition_dedup)]
│ │ │ │  
│ │ │ │  let mut slice = [1, 2, 2, 3, 3, 2, 1, 1];
│ │ │ │  
│ │ │ │  let (dedup, duplicates) = slice.partition_dedup();
│ │ │ │  
│ │ │ │  assert_eq!(dedup, [1, 2, 3, 2, 1]);
│ │ │ │  assert_eq!(duplicates, [2, 3, 1]);
      Run
      
│ │ │ │ -
      source
      pub fn partition_dedup_by<F>(&mut self, same_bucket: F) -> (&mut [T], &mut [T])
      where
│ │ │ │ -    F: FnMut(&mut T, &mut T) -> bool,
      🔬This is a nightly-only experimental API. (slice_partition_dedup #54279)
      Moves all but the first of consecutive elements to the end of the slice satisfying
│ │ │ │ +
      source
      pub fn partition_dedup_by<F>(&mut self, same_bucket: F) -> (&mut [T], &mut [T])
      where
│ │ │ │ +    F: FnMut(&mut T, &mut T) -> bool,
      🔬This is a nightly-only experimental API. (slice_partition_dedup #54279)
      Moves all but the first of consecutive elements to the end of the slice satisfying
│ │ │ │  a given equality relation.
      
│ │ │ │  
      Returns two slices. The first contains no consecutive repeated elements.
│ │ │ │  The second contains all the duplicates in no specified order.
      
│ │ │ │  
      The same_bucket function is passed references to two elements from the slice and
│ │ │ │  must determine if the elements compare equal. The elements are passed in opposite order
│ │ │ │  from their order in the slice, so if same_bucket(a, b) returns true, a is moved
│ │ │ │  at the end of the slice.
      
│ │ │ │ @@ -3080,31 +3080,31 @@
│ │ │ │  
│ │ │ │  let mut slice = ["foo", "Foo", "BAZ", "Bar", "bar", "baz", "BAZ"];
│ │ │ │  
│ │ │ │  let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.eq_ignore_ascii_case(b));
│ │ │ │  
│ │ │ │  assert_eq!(dedup, ["foo", "BAZ", "Bar", "baz"]);
│ │ │ │  assert_eq!(duplicates, ["bar", "Foo", "BAZ"]);      Run
      
│ │ │ │ -
      source
      pub fn partition_dedup_by_key<K, F>(&mut self, key: F) -> (&mut [T], &mut [T])
      where
│ │ │ │ -    F: FnMut(&mut T) -> K,
│ │ │ │ -    K: PartialEq,
      🔬This is a nightly-only experimental API. (slice_partition_dedup #54279)
      Moves all but the first of consecutive elements to the end of the slice that resolve
│ │ │ │ +
      source
      pub fn partition_dedup_by_key<K, F>(&mut self, key: F) -> (&mut [T], &mut [T])
      where
│ │ │ │ +    F: FnMut(&mut T) -> K,
│ │ │ │ +    K: PartialEq,
      🔬This is a nightly-only experimental API. (slice_partition_dedup #54279)
      Moves all but the first of consecutive elements to the end of the slice that resolve
│ │ │ │  to the same key.
      
│ │ │ │  
      Returns two slices. The first contains no consecutive repeated elements.
│ │ │ │  The second contains all the duplicates in no specified order.
      
│ │ │ │  
      If the slice is sorted, the first returned slice contains no duplicates.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_partition_dedup)]
│ │ │ │  
│ │ │ │  let mut slice = [10, 20, 21, 30, 30, 20, 11, 13];
│ │ │ │  
│ │ │ │  let (dedup, duplicates) = slice.partition_dedup_by_key(|i| *i / 10);
│ │ │ │  
│ │ │ │  assert_eq!(dedup, [10, 20, 30, 20, 11]);
│ │ │ │  assert_eq!(duplicates, [21, 30, 13]);
      Run
      
│ │ │ │ -
      1.26.0 · source
      pub fn rotate_left(&mut self, mid: usize)
      Rotates the slice in-place such that the first mid elements of the
│ │ │ │ +
      1.26.0 · source
      pub fn rotate_left(&mut self, mid: usize)
      Rotates the slice in-place such that the first mid elements of the
│ │ │ │  slice move to the end while the last self.len() - mid elements move to
│ │ │ │  the front. After calling rotate_left, the element previously at index
│ │ │ │  mid will become the first element in the slice.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      This function will panic if mid is greater than the length of the
│ │ │ │  slice. Note that mid == self.len() does not panic and is a no-op
│ │ │ │  rotation.
      
│ │ │ │ @@ -3115,15 +3115,15 @@
│ │ │ │  a.rotate_left(2);
│ │ │ │  assert_eq!(a, ['c', 'd', 'e', 'f', 'a', 'b']);      Run
      
│ │ │ │  
      Rotating a subslice:
      
│ │ │ │  
│ │ │ │  
      let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
│ │ │ │  a[1..5].rotate_left(1);
│ │ │ │  assert_eq!(a, ['a', 'c', 'd', 'e', 'b', 'f']);
      Run
      
│ │ │ │ -
      1.26.0 · source
      pub fn rotate_right(&mut self, k: usize)
      Rotates the slice in-place such that the first self.len() - k
│ │ │ │ +
      1.26.0 · source
      pub fn rotate_right(&mut self, k: usize)
      Rotates the slice in-place such that the first self.len() - k
│ │ │ │  elements of the slice move to the end while the last k elements move
│ │ │ │  to the front. After calling rotate_right, the element previously at
│ │ │ │  index self.len() - k will become the first element in the slice.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      This function will panic if k is greater than the length of the
│ │ │ │  slice. Note that k == self.len() does not panic and is a no-op
│ │ │ │  rotation.
      
│ │ │ │ @@ -3134,32 +3134,32 @@
│ │ │ │  a.rotate_right(2);
│ │ │ │  assert_eq!(a, ['e', 'f', 'a', 'b', 'c', 'd']);Run
      
│ │ │ │  
      Rotating a subslice:
      
│ │ │ │  
│ │ │ │  
      let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
│ │ │ │  a[1..5].rotate_right(1);
│ │ │ │  assert_eq!(a, ['a', 'e', 'b', 'c', 'd', 'f']);
      Run
      
│ │ │ │ -
      1.50.0 · source
      pub fn fill(&mut self, value: T)
      where
│ │ │ │ -    T: Clone,
      Fills self with elements by cloning value.
      
│ │ │ │ +
      1.50.0 · source
      pub fn fill(&mut self, value: T)
      where
│ │ │ │ +    T: Clone,
      Fills self with elements by cloning value.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut buf = vec![0; 10];
│ │ │ │  buf.fill(1);
│ │ │ │  assert_eq!(buf, vec![1; 10]);
      Run
      
│ │ │ │ -
      1.51.0 · source
      pub fn fill_with<F>(&mut self, f: F)
      where
│ │ │ │ -    F: FnMut() -> T,
      Fills self with elements returned by calling a closure repeatedly.
      
│ │ │ │ +
      1.51.0 · source
      pub fn fill_with<F>(&mut self, f: F)
      where
│ │ │ │ +    F: FnMut() -> T,
      Fills self with elements returned by calling a closure repeatedly.
      
│ │ │ │  
      This method uses a closure to create new values. If you’d rather
│ │ │ │ -Clone a given value, use fill. If you want to use the Default
│ │ │ │ -trait to generate values, you can pass Default::default as the
│ │ │ │ +Clone a given value, use fill. If you want to use the Default
│ │ │ │ +trait to generate values, you can pass Default::default as the
│ │ │ │  argument.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let mut buf = vec![1; 10];
│ │ │ │  buf.fill_with(Default::default);
│ │ │ │  assert_eq!(buf, vec![0; 10]);
      Run
      
│ │ │ │ -
      1.7.0 · source
      pub fn clone_from_slice(&mut self, src: &[T])
      where
│ │ │ │ -    T: Clone,
      Copies the elements from src into self.
      
│ │ │ │ +
      1.7.0 · source
      pub fn clone_from_slice(&mut self, src: &[T])
      where
│ │ │ │ +    T: Clone,
      Copies the elements from src into self.
      
│ │ │ │  
      The length of src must be the same as self.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      This function will panic if the two slices have different lengths.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      Cloning two elements from a slice into another:
      
│ │ │ │  
│ │ │ │  
      let src = [1, 2, 3, 4];
│ │ │ │ @@ -3176,29 +3176,29 @@
│ │ │ │  immutable references to a particular piece of data in a particular
│ │ │ │  scope. Because of this, attempting to use clone_from_slice on a
│ │ │ │  single slice will result in a compile failure:
      
│ │ │ │  
│ │ │ │  
      ⓘ
      let mut slice = [1, 2, 3, 4, 5];
│ │ │ │  
│ │ │ │  slice[..2].clone_from_slice(&slice[3..]); // compile fail!
      Run
      
│ │ │ │ -
      To work around this, we can use split_at_mut to create two distinct
│ │ │ │ +
      To work around this, we can use split_at_mut to create two distinct
│ │ │ │  sub-slices from a slice:
      
│ │ │ │  
│ │ │ │  
      let mut slice = [1, 2, 3, 4, 5];
│ │ │ │  
│ │ │ │  {
│ │ │ │      let (left, right) = slice.split_at_mut(2);
│ │ │ │      left.clone_from_slice(&right[1..]);
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(slice, [4, 5, 3, 4, 5]);
      Run
      
│ │ │ │ -
      1.9.0 · source
      pub fn copy_from_slice(&mut self, src: &[T])
      where
│ │ │ │ -    T: Copy,
      Copies all elements from src into self, using a memcpy.
      
│ │ │ │ +
      1.9.0 · source
      pub fn copy_from_slice(&mut self, src: &[T])
      where
│ │ │ │ +    T: Copy,
      Copies all elements from src into self, using a memcpy.
      
│ │ │ │  
      The length of src must be the same as self.
      
│ │ │ │ -
      If T does not implement Copy, use clone_from_slice.
      
│ │ │ │ +
      If T does not implement Copy, use clone_from_slice.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      This function will panic if the two slices have different lengths.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      Copying two elements from a slice into another:
      
│ │ │ │  
│ │ │ │  
      let src = [1, 2, 3, 4];
│ │ │ │  let mut dst = [0, 0];
│ │ │ │ @@ -3214,28 +3214,28 @@
│ │ │ │  immutable references to a particular piece of data in a particular
│ │ │ │  scope. Because of this, attempting to use copy_from_slice on a
│ │ │ │  single slice will result in a compile failure:
      
│ │ │ │  
│ │ │ │  
      ⓘ
      let mut slice = [1, 2, 3, 4, 5];
│ │ │ │  
│ │ │ │  slice[..2].copy_from_slice(&slice[3..]); // compile fail!
      Run
      
│ │ │ │ -
      To work around this, we can use split_at_mut to create two distinct
│ │ │ │ +
      To work around this, we can use split_at_mut to create two distinct
│ │ │ │  sub-slices from a slice:
      
│ │ │ │  
│ │ │ │  
      let mut slice = [1, 2, 3, 4, 5];
│ │ │ │  
│ │ │ │  {
│ │ │ │      let (left, right) = slice.split_at_mut(2);
│ │ │ │      left.copy_from_slice(&right[1..]);
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(slice, [4, 5, 3, 4, 5]);
      Run
      
│ │ │ │ -
      1.37.0 · source
      pub fn copy_within<R>(&mut self, src: R, dest: usize)
      where
│ │ │ │ -    R: RangeBounds<usize>,
│ │ │ │ -    T: Copy,
      Copies elements from one part of the slice to another part of itself,
│ │ │ │ +
      1.37.0 · source
      pub fn copy_within<R>(&mut self, src: R, dest: usize)
      where
│ │ │ │ +    R: RangeBounds<usize>,
│ │ │ │ +    T: Copy,
      Copies elements from one part of the slice to another part of itself,
│ │ │ │  using a memmove.
      
│ │ │ │  
      src is the range within self to copy from. dest is the starting
│ │ │ │  index of the range within self to copy to, which will have the same
│ │ │ │  length as src. The two ranges may overlap. The ends of the two ranges
│ │ │ │  must be less than or equal to self.len().
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      This function will panic if either range exceeds the end of the slice,
│ │ │ │ @@ -3244,15 +3244,15 @@
│ │ │ │  
      Copying four bytes within a slice:
      
│ │ │ │  
│ │ │ │  
      let mut bytes = *b"Hello, World!";
│ │ │ │  
│ │ │ │  bytes.copy_within(1..5, 8);
│ │ │ │  
│ │ │ │  assert_eq!(&bytes, b"Hello, Wello!");
      Run
      
│ │ │ │ -
      1.27.0 · source
      pub fn swap_with_slice(&mut self, other: &mut [T])
      Swaps all elements in self with those in other.
      
│ │ │ │ +
      1.27.0 · source
      pub fn swap_with_slice(&mut self, other: &mut [T])
      Swaps all elements in self with those in other.
      
│ │ │ │  
      The length of other must be the same as self.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      This function will panic if the two slices have different lengths.
      
│ │ │ │  
      §Example
      
│ │ │ │  
      Swapping two elements across slices:
      
│ │ │ │  
│ │ │ │  
      let mut slice1 = [0, 0];
│ │ │ │ @@ -3265,26 +3265,26 @@
│ │ │ │  
      Rust enforces that there can only be one mutable reference to a
│ │ │ │  particular piece of data in a particular scope. Because of this,
│ │ │ │  attempting to use swap_with_slice on a single slice will result in
│ │ │ │  a compile failure:
      
│ │ │ │  
│ │ │ │  
      ⓘ
      let mut slice = [1, 2, 3, 4, 5];
│ │ │ │  slice[..2].swap_with_slice(&mut slice[3..]); // compile fail!
      Run
      
│ │ │ │ -
      To work around this, we can use split_at_mut to create two distinct
│ │ │ │ +
      To work around this, we can use split_at_mut to create two distinct
│ │ │ │  mutable sub-slices from a slice:
      
│ │ │ │  
│ │ │ │  
      let mut slice = [1, 2, 3, 4, 5];
│ │ │ │  
│ │ │ │  {
│ │ │ │      let (left, right) = slice.split_at_mut(2);
│ │ │ │      left.swap_with_slice(&mut right[1..]);
│ │ │ │  }
│ │ │ │  
│ │ │ │  assert_eq!(slice, [4, 5, 3, 1, 2]);
      Run
      
│ │ │ │ -
      1.30.0 · source
      pub unsafe fn align_to<U>(&self) -> (&[T], &[U], &[T])
      Transmute the slice to a slice of another type, ensuring alignment of the types is
│ │ │ │ +
      1.30.0 · source
      pub unsafe fn align_to<U>(&self) -> (&[T], &[U], &[T])
      Transmute the slice to a slice of another type, ensuring alignment of the types is
│ │ │ │  maintained.
      
│ │ │ │  
      This method splits the slice into three distinct slices: prefix, correctly aligned middle
│ │ │ │  slice of a new type, and the suffix slice. The middle part will be as big as possible under
│ │ │ │  the given alignment constraint and element size.
      
│ │ │ │  
      This method has no purpose when either input element T or output element U are
│ │ │ │  zero-sized and will return the original slice without splitting anything.
      
│ │ │ │  
      §Safety
      
│ │ │ │ @@ -3296,15 +3296,15 @@
│ │ │ │  
      unsafe {
│ │ │ │      let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
│ │ │ │      let (prefix, shorts, suffix) = bytes.align_to::<u16>();
│ │ │ │      // less_efficient_algorithm_for_bytes(prefix);
│ │ │ │      // more_efficient_algorithm_for_aligned_shorts(shorts);
│ │ │ │      // less_efficient_algorithm_for_bytes(suffix);
│ │ │ │  }
      Run
      
│ │ │ │ -
      1.30.0 · source
      pub unsafe fn align_to_mut<U>(&mut self) -> (&mut [T], &mut [U], &mut [T])
      Transmute the mutable slice to a mutable slice of another type, ensuring alignment of the
│ │ │ │ +
      1.30.0 · source
      pub unsafe fn align_to_mut<U>(&mut self) -> (&mut [T], &mut [U], &mut [T])
      Transmute the mutable slice to a mutable slice of another type, ensuring alignment of the
│ │ │ │  types is maintained.
      
│ │ │ │  
      This method splits the slice into three distinct slices: prefix, correctly aligned middle
│ │ │ │  slice of a new type, and the suffix slice. The middle part will be as big as possible under
│ │ │ │  the given alignment constraint and element size.
      
│ │ │ │  
      This method has no purpose when either input element T or output element U are
│ │ │ │  zero-sized and will return the original slice without splitting anything.
      
│ │ │ │  
      §Safety
      
│ │ │ │ @@ -3316,19 +3316,19 @@
│ │ │ │  
      unsafe {
│ │ │ │      let mut bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
│ │ │ │      let (prefix, shorts, suffix) = bytes.align_to_mut::<u16>();
│ │ │ │      // less_efficient_algorithm_for_bytes(prefix);
│ │ │ │      // more_efficient_algorithm_for_aligned_shorts(shorts);
│ │ │ │      // less_efficient_algorithm_for_bytes(suffix);
│ │ │ │  }
      Run
      
│ │ │ │ -
      source
      pub fn as_simd<const LANES: usize>(&self) -> (&[T], &[Simd<T, LANES>], &[T])
      where
│ │ │ │ -    Simd<T, LANES>: AsRef<[T; LANES]>,
│ │ │ │ -    T: SimdElement,
│ │ │ │ -    LaneCount<LANES>: SupportedLaneCount,
      🔬This is a nightly-only experimental API. (portable_simd #86656)
      Split a slice into a prefix, a middle of aligned SIMD types, and a suffix.
      
│ │ │ │ -
      This is a safe wrapper around slice::align_to, so has the same weak
│ │ │ │ +
      source
      pub fn as_simd<const LANES: usize>(&self) -> (&[T], &[Simd<T, LANES>], &[T])
      where
│ │ │ │ +    Simd<T, LANES>: AsRef<[T; LANES]>,
│ │ │ │ +    T: SimdElement,
│ │ │ │ +    LaneCount<LANES>: SupportedLaneCount,
      🔬This is a nightly-only experimental API. (portable_simd #86656)
      Split a slice into a prefix, a middle of aligned SIMD types, and a suffix.
      
│ │ │ │ +
      This is a safe wrapper around slice::align_to, so has the same weak
│ │ │ │  postconditions as that method.  You’re only assured that
│ │ │ │  self.len() == prefix.len() + middle.len() * LANES + suffix.len().
      
│ │ │ │  
      Notably, all of the following are possible:
      
│ │ │ │  
        
│ │ │ │  
      • prefix.len() >= LANES.
        • 
│ │ │ │  
      • middle.is_empty() despite self.len() >= 3 * LANES.
        • 
│ │ │ │  
      • suffix.len() >= LANES.
        • 
│ │ │ │ @@ -3366,95 +3366,95 @@
│ │ │ │      ]);
│ │ │ │      let sums = middle.iter().copied().fold(sums, f32x4::add);
│ │ │ │      sums.reduce_sum()
│ │ │ │  }
│ │ │ │  
│ │ │ │  let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
│ │ │ │  assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);        Run
      
│ │ │ │ -
      source
      pub fn as_simd_mut<const LANES: usize>(
│ │ │ │ +
      source
      pub fn as_simd_mut<const LANES: usize>(
│ │ │ │      &mut self
│ │ │ │ -) -> (&mut [T], &mut [Simd<T, LANES>], &mut [T])
      where
│ │ │ │ -    Simd<T, LANES>: AsMut<[T; LANES]>,
│ │ │ │ -    T: SimdElement,
│ │ │ │ -    LaneCount<LANES>: SupportedLaneCount,
      🔬This is a nightly-only experimental API. (portable_simd #86656)
      Split a mutable slice into a mutable prefix, a middle of aligned SIMD types,
│ │ │ │ +) -> (&mut [T], &mut [Simd<T, LANES>], &mut [T])
      where
│ │ │ │ +    Simd<T, LANES>: AsMut<[T; LANES]>,
│ │ │ │ +    T: SimdElement,
│ │ │ │ +    LaneCount<LANES>: SupportedLaneCount,
      🔬This is a nightly-only experimental API. (portable_simd #86656)
      Split a mutable slice into a mutable prefix, a middle of aligned SIMD types,
│ │ │ │  and a mutable suffix.
      
│ │ │ │ -
      This is a safe wrapper around slice::align_to_mut, so has the same weak
│ │ │ │ +
      This is a safe wrapper around slice::align_to_mut, so has the same weak
│ │ │ │  postconditions as that method.  You’re only assured that
│ │ │ │  self.len() == prefix.len() + middle.len() * LANES + suffix.len().
      
│ │ │ │  
      Notably, all of the following are possible:
      
│ │ │ │  
        
│ │ │ │  
      • prefix.len() >= LANES.
        • 
│ │ │ │  
      • middle.is_empty() despite self.len() >= 3 * LANES.
        • 
│ │ │ │  
      • suffix.len() >= LANES.
        • 
│ │ │ │  
      
│ │ │ │  
      That said, this is a safe method, so if you’re only writing safe code,
│ │ │ │  then this can at most cause incorrect logic, not unsoundness.
      
│ │ │ │ -
      This is the mutable version of slice::as_simd; see that for examples.
      
│ │ │ │ +
      This is the mutable version of slice::as_simd; see that for examples.
      
│ │ │ │  
      §Panics
      
│ │ │ │  
      This will panic if the size of the SIMD type is different from
│ │ │ │  LANES times that of the scalar.
      
│ │ │ │  
      At the time of writing, the trait restrictions on Simd<T, LANES> keeps
│ │ │ │  that from ever happening, as only power-of-two numbers of lanes are
│ │ │ │  supported.  It’s possible that, in the future, those restrictions might
│ │ │ │  be lifted in a way that would make it possible to see panics from this
│ │ │ │  method for something like LANES == 3.
      
│ │ │ │ -
      source
      pub fn is_sorted(&self) -> bool
      where
│ │ │ │ -    T: PartialOrd,
      🔬This is a nightly-only experimental API. (is_sorted #53485)
      Checks if the elements of this slice are sorted.
      
│ │ │ │ +
      source
      pub fn is_sorted(&self) -> bool
      where
│ │ │ │ +    T: PartialOrd,
      🔬This is a nightly-only experimental API. (is_sorted #53485)
      Checks if the elements of this slice are sorted.
      
│ │ │ │  
      That is, for each element a and its following element b, a <= b must hold. If the
│ │ │ │  slice yields exactly zero or one element, true is returned.
      
│ │ │ │  
      Note that if Self::Item is only PartialOrd, but not Ord, the above definition
│ │ │ │  implies that this function returns false if any two consecutive items are not
│ │ │ │  comparable.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(is_sorted)]
│ │ │ │  let empty: [i32; 0] = [];
│ │ │ │  
│ │ │ │  assert!([1, 2, 2, 9].is_sorted());
│ │ │ │  assert!(![1, 3, 2, 4].is_sorted());
│ │ │ │  assert!([0].is_sorted());
│ │ │ │  assert!(empty.is_sorted());
│ │ │ │  assert!(![0.0, 1.0, f32::NAN].is_sorted());
      Run
      
│ │ │ │ -
      source
      pub fn is_sorted_by<'a, F>(&'a self, compare: F) -> bool
      where
│ │ │ │ -    F: FnMut(&'a T, &'a T) -> bool,
      🔬This is a nightly-only experimental API. (is_sorted #53485)
      Checks if the elements of this slice are sorted using the given comparator function.
      
│ │ │ │ +
      source
      pub fn is_sorted_by<'a, F>(&'a self, compare: F) -> bool
      where
│ │ │ │ +    F: FnMut(&'a T, &'a T) -> bool,
      🔬This is a nightly-only experimental API. (is_sorted #53485)
      Checks if the elements of this slice are sorted using the given comparator function.
      
│ │ │ │  
      Instead of using PartialOrd::partial_cmp, this function uses the given compare
│ │ │ │  function to determine whether two elements are to be considered in sorted order.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(is_sorted)]
│ │ │ │  
│ │ │ │  assert!([1, 2, 2, 9].is_sorted_by(|a, b| a <= b));
│ │ │ │  assert!(![1, 2, 2, 9].is_sorted_by(|a, b| a < b));
│ │ │ │  
│ │ │ │  assert!([0].is_sorted_by(|a, b| true));
│ │ │ │  assert!([0].is_sorted_by(|a, b| false));
│ │ │ │  
│ │ │ │  let empty: [i32; 0] = [];
│ │ │ │  assert!(empty.is_sorted_by(|a, b| false));
│ │ │ │  assert!(empty.is_sorted_by(|a, b| true));
      Run
      
│ │ │ │ -
      source
      pub fn is_sorted_by_key<'a, F, K>(&'a self, f: F) -> bool
      where
│ │ │ │ -    F: FnMut(&'a T) -> K,
│ │ │ │ -    K: PartialOrd,
      🔬This is a nightly-only experimental API. (is_sorted #53485)
      Checks if the elements of this slice are sorted using the given key extraction function.
      
│ │ │ │ +
      source
      pub fn is_sorted_by_key<'a, F, K>(&'a self, f: F) -> bool
      where
│ │ │ │ +    F: FnMut(&'a T) -> K,
│ │ │ │ +    K: PartialOrd,
      🔬This is a nightly-only experimental API. (is_sorted #53485)
      Checks if the elements of this slice are sorted using the given key extraction function.
      
│ │ │ │  
      Instead of comparing the slice’s elements directly, this function compares the keys of the
│ │ │ │ -elements, as determined by f. Apart from that, it’s equivalent to is_sorted; see its
│ │ │ │ +elements, as determined by f. Apart from that, it’s equivalent to is_sorted; see its
│ │ │ │  documentation for more information.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(is_sorted)]
│ │ │ │  
│ │ │ │  assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
│ │ │ │  assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
      Run
      
│ │ │ │ -
      1.52.0 · source
      pub fn partition_point<P>(&self, pred: P) -> usize
      where
│ │ │ │ -    P: FnMut(&T) -> bool,
      Returns the index of the partition point according to the given predicate
│ │ │ │ +
      1.52.0 · source
      pub fn partition_point<P>(&self, pred: P) -> usize
      where
│ │ │ │ +    P: FnMut(&T) -> bool,
      Returns the index of the partition point according to the given predicate
│ │ │ │  (the index of the first element of the second partition).
      
│ │ │ │  
      The slice is assumed to be partitioned according to the given predicate.
│ │ │ │  This means that all elements for which the predicate returns true are at the start of the slice
│ │ │ │  and all elements for which the predicate returns false are at the end.
│ │ │ │  For example, [7, 15, 3, 5, 4, 12, 6] is partitioned under the predicate x % 2 != 0
│ │ │ │  (all odd numbers are at the start, all even at the end).
      
│ │ │ │  
      If this slice is not partitioned, the returned result is unspecified and meaningless,
│ │ │ │  as this method performs a kind of binary search.
      
│ │ │ │ -
      See also binary_search, binary_search_by, and binary_search_by_key.
      
│ │ │ │ +
      See also binary_search, binary_search_by, and binary_search_by_key.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = [1, 2, 3, 3, 5, 6, 7];
│ │ │ │  let i = v.partition_point(|&x| x < 5);
│ │ │ │  
│ │ │ │  assert_eq!(i, 4);
│ │ │ │  assert!(v[..i].iter().all(|&x| x < 5));
│ │ │ │  assert!(v[i..].iter().all(|&x| !(x < 5)));
      Run
      
│ │ │ │ @@ -3469,16 +3469,16 @@
│ │ │ │  sort order:
      
│ │ │ │  
│ │ │ │  
      let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
│ │ │ │  let num = 42;
│ │ │ │  let idx = s.partition_point(|&x| x < num);
│ │ │ │  s.insert(idx, num);
│ │ │ │  assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
      Run
      
│ │ │ │ -
      source
      pub fn take<'a, R>(self: &mut &'a [T], range: R) -> Option<&'a [T]>
      where
│ │ │ │ -    R: OneSidedRange<usize>,
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the subslice corresponding to the given range
│ │ │ │ +
      source
      pub fn take<'a, R>(self: &mut &'a [T], range: R) -> Option<&'a [T]>
      where
│ │ │ │ +    R: OneSidedRange<usize>,
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the subslice corresponding to the given range
│ │ │ │  and returns a reference to it.
      
│ │ │ │  
      Returns None and does not modify the slice if the given
│ │ │ │  range is out of bounds.
      
│ │ │ │  
      Note that this method only accepts one-sided ranges such as
│ │ │ │  2.. or ..6, but not 2..6.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      Taking the first three elements of a slice:
      
│ │ │ │ @@ -3506,16 +3506,16 @@
│ │ │ │  let mut slice: &[_] = &['a', 'b', 'c', 'd'];
│ │ │ │  
│ │ │ │  assert_eq!(None, slice.take(5..));
│ │ │ │  assert_eq!(None, slice.take(..5));
│ │ │ │  assert_eq!(None, slice.take(..=4));
│ │ │ │  let expected: &[char] = &['a', 'b', 'c', 'd'];
│ │ │ │  assert_eq!(Some(expected), slice.take(..4));      Run
      
│ │ │ │ -
      source
      pub fn take_mut<'a, R>(self: &mut &'a mut [T], range: R) -> Option<&'a mut [T]>
      where
│ │ │ │ -    R: OneSidedRange<usize>,
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the subslice corresponding to the given range
│ │ │ │ +
      source
      pub fn take_mut<'a, R>(self: &mut &'a mut [T], range: R) -> Option<&'a mut [T]>
      where
│ │ │ │ +    R: OneSidedRange<usize>,
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the subslice corresponding to the given range
│ │ │ │  and returns a mutable reference to it.
      
│ │ │ │  
      Returns None and does not modify the slice if the given
│ │ │ │  range is out of bounds.
      
│ │ │ │  
      Note that this method only accepts one-sided ranges such as
│ │ │ │  2.. or ..6, but not 2..6.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      Taking the first three elements of a slice:
      
│ │ │ │ @@ -3543,179 +3543,179 @@
│ │ │ │  let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
│ │ │ │  
│ │ │ │  assert_eq!(None, slice.take_mut(5..));
│ │ │ │  assert_eq!(None, slice.take_mut(..5));
│ │ │ │  assert_eq!(None, slice.take_mut(..=4));
│ │ │ │  let expected: &mut [_] = &mut ['a', 'b', 'c', 'd'];
│ │ │ │  assert_eq!(Some(expected), slice.take_mut(..4));Run
      
│ │ │ │ -
      source
      pub fn take_first<'a>(self: &mut &'a [T]) -> Option<&'a T>
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the first element of the slice and returns a reference
│ │ │ │ +
      source
      pub fn take_first<'a>(self: &mut &'a [T]) -> Option<&'a T>
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the first element of the slice and returns a reference
│ │ │ │  to it.
      
│ │ │ │  
      Returns None if the slice is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_take)]
│ │ │ │  
│ │ │ │  let mut slice: &[_] = &['a', 'b', 'c'];
│ │ │ │  let first = slice.take_first().unwrap();
│ │ │ │  
│ │ │ │  assert_eq!(slice, &['b', 'c']);
│ │ │ │  assert_eq!(first, &'a');
      Run
      
│ │ │ │ -
      source
      pub fn take_first_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the first element of the slice and returns a mutable
│ │ │ │ +
      source
      pub fn take_first_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the first element of the slice and returns a mutable
│ │ │ │  reference to it.
      
│ │ │ │  
      Returns None if the slice is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_take)]
│ │ │ │  
│ │ │ │  let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
│ │ │ │  let first = slice.take_first_mut().unwrap();
│ │ │ │  *first = 'd';
│ │ │ │  
│ │ │ │  assert_eq!(slice, &['b', 'c']);
│ │ │ │  assert_eq!(first, &'d');
      Run
      
│ │ │ │ -
      source
      pub fn take_last<'a>(self: &mut &'a [T]) -> Option<&'a T>
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the last element of the slice and returns a reference
│ │ │ │ +
      source
      pub fn take_last<'a>(self: &mut &'a [T]) -> Option<&'a T>
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the last element of the slice and returns a reference
│ │ │ │  to it.
      
│ │ │ │  
      Returns None if the slice is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_take)]
│ │ │ │  
│ │ │ │  let mut slice: &[_] = &['a', 'b', 'c'];
│ │ │ │  let last = slice.take_last().unwrap();
│ │ │ │  
│ │ │ │  assert_eq!(slice, &['a', 'b']);
│ │ │ │  assert_eq!(last, &'c');
      Run
      
│ │ │ │ -
      source
      pub fn take_last_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the last element of the slice and returns a mutable
│ │ │ │ +
      source
      pub fn take_last_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>
      🔬This is a nightly-only experimental API. (slice_take #62280)
      Removes the last element of the slice and returns a mutable
│ │ │ │  reference to it.
      
│ │ │ │  
      Returns None if the slice is empty.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(slice_take)]
│ │ │ │  
│ │ │ │  let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
│ │ │ │  let last = slice.take_last_mut().unwrap();
│ │ │ │  *last = 'd';
│ │ │ │  
│ │ │ │  assert_eq!(slice, &['a', 'b']);
│ │ │ │  assert_eq!(last, &'d');
      Run
      
│ │ │ │ -
      source
      pub unsafe fn get_many_unchecked_mut<const N: usize>(
│ │ │ │ +
      source
      pub unsafe fn get_many_unchecked_mut<const N: usize>(
│ │ │ │      &mut self,
│ │ │ │ -    indices: [usize; N]
│ │ │ │ -) -> [&mut T; N]
      🔬This is a nightly-only experimental API. (get_many_mut #104642)
      Returns mutable references to many indices at once, without doing any checks.
      
│ │ │ │ -
      For a safe alternative see get_many_mut.
      
│ │ │ │ +    indices: [usize; N]
│ │ │ │ +) -> [&mut T; N]
      🔬This is a nightly-only experimental API. (get_many_mut #104642)
      Returns mutable references to many indices at once, without doing any checks.
      
│ │ │ │ +
      For a safe alternative see get_many_mut.
      
│ │ │ │  
      §Safety
      
│ │ │ │  
      Calling this method with overlapping or out-of-bounds indices is undefined behavior
│ │ │ │  even if the resulting references are not used.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(get_many_mut)]
│ │ │ │  
│ │ │ │  let x = &mut [1, 2, 4];
│ │ │ │  
│ │ │ │  unsafe {
│ │ │ │      let [a, b] = x.get_many_unchecked_mut([0, 2]);
│ │ │ │      *a *= 10;
│ │ │ │      *b *= 100;
│ │ │ │  }
│ │ │ │  assert_eq!(x, &[10, 2, 400]);
      Run
      
│ │ │ │ -
      source
      pub fn get_many_mut<const N: usize>(
│ │ │ │ +
      source
      pub fn get_many_mut<const N: usize>(
│ │ │ │      &mut self,
│ │ │ │ -    indices: [usize; N]
│ │ │ │ -) -> Result<[&mut T; N], GetManyMutError<N>>
      🔬This is a nightly-only experimental API. (get_many_mut #104642)
      Returns mutable references to many indices at once.
      
│ │ │ │ +    indices: [usize; N]
│ │ │ │ +) -> Result<[&mut T; N], GetManyMutError<N>>
      🔬This is a nightly-only experimental API. (get_many_mut #104642)
      Returns mutable references to many indices at once.
      
│ │ │ │  
      Returns an error if any index is out-of-bounds, or if the same index was
│ │ │ │  passed more than once.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      #![feature(get_many_mut)]
│ │ │ │  
│ │ │ │  let v = &mut [1, 2, 3];
│ │ │ │  if let Ok([a, b]) = v.get_many_mut([0, 2]) {
│ │ │ │      *a = 413;
│ │ │ │      *b = 612;
│ │ │ │  }
│ │ │ │  assert_eq!(v, &[413, 2, 612]);
      Run
      
│ │ │ │ -
      Trait Implementations§
      1.5.0 · source§
      impl<T, A: Allocator> AsMut<[T]> for Vec<T, A>
      source§
      fn as_mut(&mut self) -> &mut [T]
      Converts this type into a mutable reference of the (usually inferred) input type.
      1.5.0 · source§
      impl<T, A: Allocator> AsMut<Vec<T, A>> for Vec<T, A>
      source§
      fn as_mut(&mut self) -> &mut Vec<T, A>
      Converts this type into a mutable reference of the (usually inferred) input type.
      source§
      impl<T, A: Allocator> AsRef<[T]> for Vec<T, A>
      source§
      fn as_ref(&self) -> &[T]
      Converts this type into a shared reference of the (usually inferred) input type.
      source§
      impl<T, A: Allocator> AsRef<Vec<T, A>> for Vec<T, A>
      source§
      fn as_ref(&self) -> &Vec<T, A>
      Converts this type into a shared reference of the (usually inferred) input type.
      source§
      impl<T, A: Allocator> Borrow<[T]> for Vec<T, A>
      source§
      fn borrow(&self) -> &[T]
      Immutably borrows from an owned value. Read more
      source§
      impl<T, A: Allocator> BorrowMut<[T]> for Vec<T, A>
      source§
      fn borrow_mut(&mut self) -> &mut [T]
      Mutably borrows from an owned value. Read more
      source§
      impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A>
      source§
      fn clone(&self) -> Self
      Returns a copy of the value. Read more
      source§
      fn clone_from(&mut self, other: &Self)
      Performs copy-assignment from source. Read more
      source§
      impl<T: Debug, A: Allocator> Debug for Vec<T, A>
      source§
      fn fmt(&self, f: &mut Formatter<'_>) -> Result
      Formats the value using the given formatter. Read more
      source§
      impl<T> Default for Vec<T>
      source§
      fn default() -> Vec<T>
      Creates an empty Vec<T>.
      
│ │ │ │ +
      Trait Implementations§
      1.5.0 · source§
      impl<T, A: Allocator> AsMut<[T]> for Vec<T, A>
      source§
      fn as_mut(&mut self) -> &mut [T]
      Converts this type into a mutable reference of the (usually inferred) input type.
      1.5.0 · source§
      impl<T, A: Allocator> AsMut<Vec<T, A>> for Vec<T, A>
      source§
      fn as_mut(&mut self) -> &mut Vec<T, A>
      Converts this type into a mutable reference of the (usually inferred) input type.
      source§
      impl<T, A: Allocator> AsRef<[T]> for Vec<T, A>
      source§
      fn as_ref(&self) -> &[T]
      Converts this type into a shared reference of the (usually inferred) input type.
      source§
      impl<T, A: Allocator> AsRef<Vec<T, A>> for Vec<T, A>
      source§
      fn as_ref(&self) -> &Vec<T, A>
      Converts this type into a shared reference of the (usually inferred) input type.
      source§
      impl<T, A: Allocator> Borrow<[T]> for Vec<T, A>
      source§
      fn borrow(&self) -> &[T]
      Immutably borrows from an owned value. Read more
      source§
      impl<T, A: Allocator> BorrowMut<[T]> for Vec<T, A>
      source§
      fn borrow_mut(&mut self) -> &mut [T]
      Mutably borrows from an owned value. Read more
      source§
      impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A>
      source§
      fn clone(&self) -> Self
      Returns a copy of the value. Read more
      source§
      fn clone_from(&mut self, other: &Self)
      Performs copy-assignment from source. Read more
      source§
      impl<T: Debug, A: Allocator> Debug for Vec<T, A>
      source§
      fn fmt(&self, f: &mut Formatter<'_>) -> Result
      Formats the value using the given formatter. Read more
      source§
      impl<T> Default for Vec<T>
      source§
      fn default() -> Vec<T>
      Creates an empty Vec<T>.
      
│ │ │ │  
      The vector will not allocate until elements are pushed onto it.
      
│ │ │ │ -
      source§
      impl<T, A: Allocator> Deref for Vec<T, A>
      §
      type Target = [T]
      The resulting type after dereferencing.
      source§
      fn deref(&self) -> &[T]
      Dereferences the value.
      source§
      impl<T, A: Allocator> DerefMut for Vec<T, A>
      source§
      fn deref_mut(&mut self) -> &mut [T]
      Mutably dereferences the value.
      source§
      impl<T, A: Allocator> Drop for Vec<T, A>
      source§
      fn drop(&mut self)
      Executes the destructor for this type. Read more
      1.2.0 · source§
      impl<'a, T: Copy + 'a, A: Allocator> Extend<&'a T> for Vec<T, A>
      Extend implementation that copies elements out of references before pushing them onto the Vec.
      
│ │ │ │ -
      This implementation is specialized for slice iterators, where it uses copy_from_slice to
│ │ │ │ +
      source§
      impl<T, A: Allocator> Deref for Vec<T, A>
      §
      type Target = [T]
      The resulting type after dereferencing.
      source§
      fn deref(&self) -> &[T]
      Dereferences the value.
      source§
      impl<T, A: Allocator> DerefMut for Vec<T, A>
      source§
      fn deref_mut(&mut self) -> &mut [T]
      Mutably dereferences the value.
      source§
      impl<T, A: Allocator> Drop for Vec<T, A>
      source§
      fn drop(&mut self)
      Executes the destructor for this type. Read more
      1.2.0 · source§
      impl<'a, T: Copy + 'a, A: Allocator> Extend<&'a T> for Vec<T, A>
      Extend implementation that copies elements out of references before pushing them onto the Vec.
      
│ │ │ │ +
      This implementation is specialized for slice iterators, where it uses copy_from_slice to
│ │ │ │  append the entire slice at once.
      
│ │ │ │ -
      source§
      fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)
      Extends a collection with the contents of an iterator. Read more
      source§
      fn extend_one(&mut self, item: &'a T)
      🔬This is a nightly-only experimental API. (extend_one #72631)
      Extends a collection with exactly one element.
      source§
      fn extend_reserve(&mut self, additional: usize)
      🔬This is a nightly-only experimental API. (extend_one #72631)
      Reserves capacity in a collection for the given number of additional elements. Read more
      source§
      impl<T, A: Allocator> Extend<T> for Vec<T, A>
      source§
      fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)
      Extends a collection with the contents of an iterator. Read more
      source§
      fn extend_one(&mut self, item: T)
      🔬This is a nightly-only experimental API. (extend_one #72631)
      Extends a collection with exactly one element.
      source§
      fn extend_reserve(&mut self, additional: usize)
      🔬This is a nightly-only experimental API. (extend_one #72631)
      Reserves capacity in a collection for the given number of additional elements. Read more
      source§
      impl<T: Clone> From<&[T]> for Vec<T>
      source§
      fn from(s: &[T]) -> Vec<T>
      Allocate a Vec<T> and fill it by cloning s’s items.
      
│ │ │ │ +
      source§
      fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)
      Extends a collection with the contents of an iterator. Read more
      source§
      fn extend_one(&mut self, item: &'a T)
      🔬This is a nightly-only experimental API. (extend_one #72631)
      Extends a collection with exactly one element.
      source§
      fn extend_reserve(&mut self, additional: usize)
      🔬This is a nightly-only experimental API. (extend_one #72631)
      Reserves capacity in a collection for the given number of additional elements. Read more
      source§
      impl<T, A: Allocator> Extend<T> for Vec<T, A>
      source§
      fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)
      Extends a collection with the contents of an iterator. Read more
      source§
      fn extend_one(&mut self, item: T)
      🔬This is a nightly-only experimental API. (extend_one #72631)
      Extends a collection with exactly one element.
      source§
      fn extend_reserve(&mut self, additional: usize)
      🔬This is a nightly-only experimental API. (extend_one #72631)
      Reserves capacity in a collection for the given number of additional elements. Read more
      source§
      impl<T: Clone> From<&[T]> for Vec<T>
      source§
      fn from(s: &[T]) -> Vec<T>
      Allocate a Vec<T> and fill it by cloning s’s items.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      assert_eq!(Vec::from(&[1, 2, 3][..]), vec![1, 2, 3]);
      Run
      
│ │ │ │ -
      1.74.0 · source§
      impl<T: Clone, const N: usize> From<&[T; N]> for Vec<T>
      source§
      fn from(s: &[T; N]) -> Vec<T>
      Allocate a Vec<T> and fill it by cloning s’s items.
      
│ │ │ │ +
      1.74.0 · source§
      impl<T: Clone, const N: usize> From<&[T; N]> for Vec<T>
      source§
      fn from(s: &[T; N]) -> Vec<T>
      Allocate a Vec<T> and fill it by cloning s’s items.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      assert_eq!(Vec::from(&[1, 2, 3]), vec![1, 2, 3]);
      Run
      
│ │ │ │ -
      1.28.0 · source§
      impl<'a, T: Clone> From<&'a Vec<T>> for Cow<'a, [T]>
      source§
      fn from(v: &'a Vec<T>) -> Cow<'a, [T]>
      Creates a Borrowed variant of Cow
│ │ │ │ +
      1.28.0 · source§
      impl<'a, T: Clone> From<&'a Vec<T>> for Cow<'a, [T]>
      source§
      fn from(v: &'a Vec<T>) -> Cow<'a, [T]>
      Creates a Borrowed variant of Cow
│ │ │ │  from a reference to Vec.
      
│ │ │ │  
      This conversion does not allocate or clone the data.
      
│ │ │ │ -
      1.19.0 · source§
      impl<T: Clone> From<&mut [T]> for Vec<T>
      source§
      fn from(s: &mut [T]) -> Vec<T>
      Allocate a Vec<T> and fill it by cloning s’s items.
      
│ │ │ │ +
      1.19.0 · source§
      impl<T: Clone> From<&mut [T]> for Vec<T>
      source§
      fn from(s: &mut [T]) -> Vec<T>
      Allocate a Vec<T> and fill it by cloning s’s items.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      assert_eq!(Vec::from(&mut [1, 2, 3][..]), vec![1, 2, 3]);
      Run
      
│ │ │ │ -
      1.74.0 · source§
      impl<T: Clone, const N: usize> From<&mut [T; N]> for Vec<T>
      source§
      fn from(s: &mut [T; N]) -> Vec<T>
      Allocate a Vec<T> and fill it by cloning s’s items.
      
│ │ │ │ +
      1.74.0 · source§
      impl<T: Clone, const N: usize> From<&mut [T; N]> for Vec<T>
      source§
      fn from(s: &mut [T; N]) -> Vec<T>
      Allocate a Vec<T> and fill it by cloning s’s items.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      assert_eq!(Vec::from(&mut [1, 2, 3]), vec![1, 2, 3]);
      Run
      
│ │ │ │ -
      source§
      impl From<&str> for Vec<u8>
      source§
      fn from(s: &str) -> Vec<u8>
      Allocate a Vec<u8> and fill it with a UTF-8 string.
      
│ │ │ │ +
      source§
      impl From<&str> for Vec<u8>
      source§
      fn from(s: &str) -> Vec<u8>
      Allocate a Vec<u8> and fill it with a UTF-8 string.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      assert_eq!(Vec::from("123"), vec![b'1', b'2', b'3']);
      Run
      
│ │ │ │ -
      1.44.0 · source§
      impl<T, const N: usize> From<[T; N]> for Vec<T>
      source§
      fn from(s: [T; N]) -> Vec<T>
      Allocate a Vec<T> and move s’s items into it.
      
│ │ │ │ +
      1.44.0 · source§
      impl<T, const N: usize> From<[T; N]> for Vec<T>
      source§
      fn from(s: [T; N]) -> Vec<T>
      Allocate a Vec<T> and move s’s items into it.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      assert_eq!(Vec::from([1, 2, 3]), vec![1, 2, 3]);
      Run
      
│ │ │ │ -
      1.5.0 · source§
      impl<T, A: Allocator> From<BinaryHeap<T, A>> for Vec<T, A>
      source§
      fn from(heap: BinaryHeap<T, A>) -> Vec<T, A>
      Converts a BinaryHeap<T> into a Vec<T>.
      
│ │ │ │ +
      1.5.0 · source§
      impl<T, A: Allocator> From<BinaryHeap<T, A>> for Vec<T, A>
      source§
      fn from(heap: BinaryHeap<T, A>) -> Vec<T, A>
      Converts a BinaryHeap<T> into a Vec<T>.
      
│ │ │ │  
      This conversion requires no data movement or allocation, and has
│ │ │ │  constant time complexity.
      
│ │ │ │ -
      1.18.0 · source§
      impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A>
      source§
      fn from(s: Box<[T], A>) -> Self
      Convert a boxed slice into a vector by transferring ownership of
│ │ │ │ +
      1.18.0 · source§
      impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A>
      source§
      fn from(s: Box<[T], A>) -> Self
      Convert a boxed slice into a vector by transferring ownership of
│ │ │ │  the existing heap allocation.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
│ │ │ │  assert_eq!(Vec::from(b), vec![1, 2, 3]);
      Run
      
│ │ │ │ -
      1.7.0 · source§
      impl From<CString> for Vec<u8>
      source§
      fn from(s: CString) -> Vec<u8>
      Converts a CString into a Vec<u8>.
      
│ │ │ │ +
      1.7.0 · source§
      impl From<CString> for Vec<u8>
      source§
      fn from(s: CString) -> Vec<u8>
      Converts a CString into a Vec<u8>.
      
│ │ │ │  
      The conversion consumes the CString, and removes the terminating NUL byte.
      
│ │ │ │ -
      1.14.0 · source§
      impl<'a, T> From<Cow<'a, [T]>> for Vec<T>
      where
│ │ │ │ -    [T]: ToOwned<Owned = Vec<T>>,
      source§
      fn from(s: Cow<'a, [T]>) -> Vec<T>
      Convert a clone-on-write slice into a vector.
      
│ │ │ │ +
      1.14.0 · source§
      impl<'a, T> From<Cow<'a, [T]>> for Vec<T>
      where
│ │ │ │ +    [T]: ToOwned<Owned = Vec<T>>,
      source§
      fn from(s: Cow<'a, [T]>) -> Vec<T>
      Convert a clone-on-write slice into a vector.
      
│ │ │ │  
      If s already owns a Vec<T>, it will be returned directly.
│ │ │ │  If s is borrowing a slice, a new Vec<T> will be allocated and
│ │ │ │  filled by cloning s’s items into it.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let o: Cow<'_, [i32]> = Cow::Owned(vec![1, 2, 3]);
│ │ │ │  let b: Cow<'_, [i32]> = Cow::Borrowed(&[1, 2, 3]);
│ │ │ │  assert_eq!(Vec::from(o), Vec::from(b));
      Run
      
│ │ │ │ -
      1.14.0 · source§
      impl From<String> for Vec<u8>
      source§
      fn from(string: String) -> Vec<u8>
      Converts the given String to a vector Vec that holds values of type u8.
      
│ │ │ │ +
      1.14.0 · source§
      impl From<String> for Vec<u8>
      source§
      fn from(string: String) -> Vec<u8>
      Converts the given String to a vector Vec that holds values of type u8.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let s1 = String::from("hello world");
│ │ │ │  let v1 = Vec::from(s1);
│ │ │ │  
│ │ │ │  for b in v1 {
│ │ │ │      println!("{b}");
│ │ │ │  }
      Run
      
│ │ │ │ -
      1.43.0 · source§
      impl From<Vec<NonZero<u8>>> for CString
      source§
      fn from(v: Vec<NonZero<u8>>) -> CString
      Converts a Vec<NonZero<u8>> into a CString without
│ │ │ │ +
      1.43.0 · source§
      impl From<Vec<NonZero<u8>>> for CString
      source§
      fn from(v: Vec<NonZero<u8>>) -> CString
      Converts a Vec<NonZero<u8>> into a CString without
│ │ │ │  copying nor checking for inner nul bytes.
      
│ │ │ │ -
      1.8.0 · source§
      impl<'a, T: Clone> From<Vec<T>> for Cow<'a, [T]>
      source§
      fn from(v: Vec<T>) -> Cow<'a, [T]>
      Creates an Owned variant of Cow
│ │ │ │ +
      1.8.0 · source§
      impl<'a, T: Clone> From<Vec<T>> for Cow<'a, [T]>
      source§
      fn from(v: Vec<T>) -> Cow<'a, [T]>
      Creates an Owned variant of Cow
│ │ │ │  from an owned instance of Vec.
      
│ │ │ │  
      This conversion does not allocate or clone the data.
      
│ │ │ │ -
      1.21.0 · source§
      impl<T, A: Allocator + Clone> From<Vec<T, A>> for Arc<[T], A>
      source§
      fn from(v: Vec<T, A>) -> Arc<[T], A>
      Allocate a reference-counted slice and move v’s items into it.
      
│ │ │ │ +
      1.21.0 · source§
      impl<T, A: Allocator + Clone> From<Vec<T, A>> for Arc<[T], A>
      source§
      fn from(v: Vec<T, A>) -> Arc<[T], A>
      Allocate a reference-counted slice and move v’s items into it.
      
│ │ │ │  
      §Example
      
│ │ │ │  
      let unique: Vec<i32> = vec![1, 2, 3];
│ │ │ │  let shared: Arc<[i32]> = Arc::from(unique);
│ │ │ │  assert_eq!(&[1, 2, 3], &shared[..]);
      Run
      
│ │ │ │ -
      1.5.0 · source§
      impl<T: Ord, A: Allocator> From<Vec<T, A>> for BinaryHeap<T, A>
      source§
      fn from(vec: Vec<T, A>) -> BinaryHeap<T, A>
      Converts a Vec<T> into a BinaryHeap<T>.
      
│ │ │ │ +
      1.5.0 · source§
      impl<T: Ord, A: Allocator> From<Vec<T, A>> for BinaryHeap<T, A>
      source§
      fn from(vec: Vec<T, A>) -> BinaryHeap<T, A>
      Converts a Vec<T> into a BinaryHeap<T>.
      
│ │ │ │  
      This conversion happens in-place, and has O(n) time complexity.
      
│ │ │ │ -
      1.20.0 · source§
      impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A>
      source§
      fn from(v: Vec<T, A>) -> Self
      Convert a vector into a boxed slice.
      
│ │ │ │ +
      1.20.0 · source§
      impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A>
      source§
      fn from(v: Vec<T, A>) -> Self
      Convert a vector into a boxed slice.
      
│ │ │ │  
      Before doing the conversion, this method discards excess capacity like Vec::shrink_to_fit.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());
      Run
      
│ │ │ │  
      Any excess capacity is removed:
      
│ │ │ │  
│ │ │ │  
      let mut vec = Vec::with_capacity(10);
│ │ │ │  vec.extend([1, 2, 3]);
│ │ │ │  
│ │ │ │  assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice());
      Run
      
│ │ │ │ -
      1.21.0 · source§
      impl<T, A: Allocator> From<Vec<T, A>> for Rc<[T], A>
      source§
      fn from(v: Vec<T, A>) -> Rc<[T], A>
      Allocate a reference-counted slice and move v’s items into it.
      
│ │ │ │ +
      1.21.0 · source§
      impl<T, A: Allocator> From<Vec<T, A>> for Rc<[T], A>
      source§
      fn from(v: Vec<T, A>) -> Rc<[T], A>
      Allocate a reference-counted slice and move v’s items into it.
      
│ │ │ │  
      §Example
      
│ │ │ │  
      let unique: Vec<i32> = vec![1, 2, 3];
│ │ │ │  let shared: Rc<[i32]> = Rc::from(unique);
│ │ │ │  assert_eq!(&[1, 2, 3], &shared[..]);
      Run
      
│ │ │ │ -
      1.10.0 · source§
      impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A>
      source§
      fn from(other: Vec<T, A>) -> Self
      Turn a Vec<T> into a VecDeque<T>.
      
│ │ │ │ +
      1.10.0 · source§
      impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A>
      source§
      fn from(other: Vec<T, A>) -> Self
      Turn a Vec<T> into a VecDeque<T>.
      
│ │ │ │  
      This conversion is guaranteed to run in O(1) time
│ │ │ │  and to not re-allocate the Vec’s buffer or allocate
│ │ │ │  any additional memory.
      
│ │ │ │ -
      1.10.0 · source§
      impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A>
      source§
      fn from(other: VecDeque<T, A>) -> Self
      Turn a VecDeque<T> into a Vec<T>.
      
│ │ │ │ +
      1.10.0 · source§
      impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A>
      source§
      fn from(other: VecDeque<T, A>) -> Self
      Turn a VecDeque<T> into a Vec<T>.
      
│ │ │ │  
      This never needs to re-allocate, but does need to do O(n) data movement if
│ │ │ │  the circular buffer doesn’t happen to be at the beginning of the allocation.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      use std::collections::VecDeque;
│ │ │ │  
│ │ │ │  // This one is *O*(1).
│ │ │ │  let deque: VecDeque<_> = (1..5).collect();
│ │ │ │ @@ -3728,24 +3728,24 @@
│ │ │ │  let mut deque: VecDeque<_> = (1..5).collect();
│ │ │ │  deque.push_front(9);
│ │ │ │  deque.push_front(8);
│ │ │ │  let ptr = deque.as_slices().1.as_ptr();
│ │ │ │  let vec = Vec::from(deque);
│ │ │ │  assert_eq!(vec, [8, 9, 1, 2, 3, 4]);
│ │ │ │  assert_eq!(vec.as_ptr(), ptr);
      Run
      
│ │ │ │ -
      source§
      impl<T> FromIterator<T> for Vec<T>
      Collects an iterator into a Vec, commonly called via Iterator::collect()
      
│ │ │ │ +
      source§
      impl<T> FromIterator<T> for Vec<T>
      Collects an iterator into a Vec, commonly called via Iterator::collect()
      
│ │ │ │  
      §Allocation behavior
      
│ │ │ │  
      In general Vec does not guarantee any particular growth or allocation strategy.
│ │ │ │  That also applies to this trait impl.
      
│ │ │ │  
      Note: This section covers implementation details and is therefore exempt from
│ │ │ │  stability guarantees.
      
│ │ │ │  
      Vec may use any or none of the following strategies,
│ │ │ │  depending on the supplied iterator:
      
│ │ │ │  
        
│ │ │ │ -
      • preallocate based on Iterator::size_hint()
│ │ │ │ +
      • preallocate based on Iterator::size_hint()
│ │ │ │  
          
│ │ │ │  
        • and panic if the number of items is outside the provided lower/upper bounds
          • 
│ │ │ │  
        
│ │ │ │  
        • 
│ │ │ │  
      • use an amortized growth strategy similar to pushing one item at a time
        • 
│ │ │ │  
      • perform the iteration in-place on the original allocation backing the iterator
        • 
│ │ │ │  
      
│ │ │ │ @@ -3765,92 +3765,92 @@
│ │ │ │      let big_temporary: Vec<u16> = (0..1024).collect();
│ │ │ │      // discard most items
│ │ │ │      let mut result: Vec<_> = big_temporary.into_iter().filter(|i| i % 100 == 0).collect();
│ │ │ │      // without this a lot of unused capacity might be moved into the global
│ │ │ │      result.shrink_to_fit();
│ │ │ │      LONG_LIVED.lock().unwrap().push(result);
│ │ │ │  }Run
      
│ │ │ │ -
      source§
      fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T>
      Creates a value from an iterator. Read more
      source§
      impl<T: Hash, A: Allocator> Hash for Vec<T, A>
      The hash of a vector is the same as that of the corresponding slice,
│ │ │ │ +
      source§
      fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T>
      Creates a value from an iterator. Read more
      source§
      impl<T: Hash, A: Allocator> Hash for Vec<T, A>
      The hash of a vector is the same as that of the corresponding slice,
│ │ │ │  as required by the core::borrow::Borrow implementation.
      
│ │ │ │  
│ │ │ │  
      use std::hash::BuildHasher;
│ │ │ │  
│ │ │ │  let b = std::hash::RandomState::new();
│ │ │ │  let v: Vec<u8> = vec![0xa8, 0x3c, 0x09];
│ │ │ │  let s: &[u8] = &[0xa8, 0x3c, 0x09];
│ │ │ │  assert_eq!(b.hash_one(v), b.hash_one(s));
      Run
      
│ │ │ │ -
      source§
      fn hash<H: Hasher>(&self, state: &mut H)
      Feeds this value into the given Hasher. Read more
      1.3.0 · source§
      fn hash_slice<H>(data: &[Self], state: &mut H)
      where
│ │ │ │ -    H: Hasher,
│ │ │ │ -    Self: Sized,
      Feeds a slice of this type into the given Hasher. Read more
      source§
      impl<T, I: SliceIndex<[T]>, A: Allocator> Index<I> for Vec<T, A>
      §
      type Output = <I as SliceIndex<[T]>>::Output
      The returned type after indexing.
      source§
      fn index(&self, index: I) -> &Self::Output
      Performs the indexing (container[index]) operation. Read more
      source§
      impl<T, I: SliceIndex<[T]>, A: Allocator> IndexMut<I> for Vec<T, A>
      source§
      fn index_mut(&mut self, index: I) -> &mut Self::Output
      Performs the mutable indexing (container[index]) operation. Read more
      source§
      impl<'a, T, A: Allocator> IntoIterator for &'a Vec<T, A>
      §
      type Item = &'a T
      The type of the elements being iterated over.
      §
      type IntoIter = Iter<'a, T>
      Which kind of iterator are we turning this into?
      source§
      fn into_iter(self) -> Self::IntoIter
      Creates an iterator from a value. Read more
      source§
      impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec<T, A>
      §
      type Item = &'a mut T
      The type of the elements being iterated over.
      §
      type IntoIter = IterMut<'a, T>
      Which kind of iterator are we turning this into?
      source§
      fn into_iter(self) -> Self::IntoIter
      Creates an iterator from a value. Read more
      source§
      impl<T, A: Allocator> IntoIterator for Vec<T, A>
      source§
      fn into_iter(self) -> Self::IntoIter
      Creates a consuming iterator, that is, one that moves each value out of
│ │ │ │ +
      source§
      fn hash<H: Hasher>(&self, state: &mut H)
      Feeds this value into the given Hasher. Read more
      1.3.0 · source§
      fn hash_slice<H>(data: &[Self], state: &mut H)
      where
│ │ │ │ +    H: Hasher,
│ │ │ │ +    Self: Sized,
      Feeds a slice of this type into the given Hasher. Read more
      source§
      impl<T, I: SliceIndex<[T]>, A: Allocator> Index<I> for Vec<T, A>
      §
      type Output = <I as SliceIndex<[T]>>::Output
      The returned type after indexing.
      source§
      fn index(&self, index: I) -> &Self::Output
      Performs the indexing (container[index]) operation. Read more
      source§
      impl<T, I: SliceIndex<[T]>, A: Allocator> IndexMut<I> for Vec<T, A>
      source§
      fn index_mut(&mut self, index: I) -> &mut Self::Output
      Performs the mutable indexing (container[index]) operation. Read more
      source§
      impl<'a, T, A: Allocator> IntoIterator for &'a Vec<T, A>
      §
      type Item = &'a T
      The type of the elements being iterated over.
      §
      type IntoIter = Iter<'a, T>
      Which kind of iterator are we turning this into?
      source§
      fn into_iter(self) -> Self::IntoIter
      Creates an iterator from a value. Read more
      source§
      impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec<T, A>
      §
      type Item = &'a mut T
      The type of the elements being iterated over.
      §
      type IntoIter = IterMut<'a, T>
      Which kind of iterator are we turning this into?
      source§
      fn into_iter(self) -> Self::IntoIter
      Creates an iterator from a value. Read more
      source§
      impl<T, A: Allocator> IntoIterator for Vec<T, A>
      source§
      fn into_iter(self) -> Self::IntoIter
      Creates a consuming iterator, that is, one that moves each value out of
│ │ │ │  the vector (from start to end). The vector cannot be used after calling
│ │ │ │  this.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      let v = vec!["a".to_string(), "b".to_string()];
│ │ │ │  let mut v_iter = v.into_iter();
│ │ │ │  
│ │ │ │  let first_element: Option<String> = v_iter.next();
│ │ │ │  
│ │ │ │  assert_eq!(first_element, Some("a".to_string()));
│ │ │ │  assert_eq!(v_iter.next(), Some("b".to_string()));
│ │ │ │  assert_eq!(v_iter.next(), None);
      Run
      
│ │ │ │ -
      §
      type Item = T
      The type of the elements being iterated over.
      §
      type IntoIter = IntoIter<T, A>
      Which kind of iterator are we turning this into?
      source§
      impl<T: Ord, A: Allocator> Ord for Vec<T, A>
      Implements ordering of vectors, lexicographically.
      
│ │ │ │ -
      source§
      fn cmp(&self, other: &Self) -> Ordering
      This method returns an Ordering between self and other. Read more
      1.21.0 · source§
      fn max(self, other: Self) -> Self
      where
│ │ │ │ -    Self: Sized,
      Compares and returns the maximum of two values. Read more
      1.21.0 · source§
      fn min(self, other: Self) -> Self
      where
│ │ │ │ -    Self: Sized,
      Compares and returns the minimum of two values. Read more
      1.50.0 · source§
      fn clamp(self, min: Self, max: Self) -> Self
      where
│ │ │ │ -    Self: Sized + PartialOrd,
      Restrict a value to a certain interval. Read more
      source§
      impl<T, U, A: Allocator> PartialEq<&[U]> for Vec<T, A>
      where
│ │ │ │ -    T: PartialEq<U>,
      source§
      fn eq(&self, other: &&[U]) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
      source§
      fn ne(&self, other: &&[U]) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
      source§
      impl<T, U, A: Allocator, const N: usize> PartialEq<&[U; N]> for Vec<T, A>
      where
│ │ │ │ -    T: PartialEq<U>,
      source§
      fn eq(&self, other: &&[U; N]) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
      source§
      fn ne(&self, other: &&[U; N]) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
      source§
      impl<T, U, A: Allocator> PartialEq<&mut [U]> for Vec<T, A>
      where
│ │ │ │ -    T: PartialEq<U>,
      source§
      fn eq(&self, other: &&mut [U]) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
      source§
      fn ne(&self, other: &&mut [U]) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
      1.48.0 · source§
      impl<T, U, A: Allocator> PartialEq<[U]> for Vec<T, A>
      where
│ │ │ │ -    T: PartialEq<U>,
      source§
      fn eq(&self, other: &[U]) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
      source§
      fn ne(&self, other: &[U]) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
      source§
      impl<T, U, A: Allocator, const N: usize> PartialEq<[U; N]> for Vec<T, A>
      where
│ │ │ │ -    T: PartialEq<U>,
      source§
      fn eq(&self, other: &[U; N]) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
      source§
      fn ne(&self, other: &[U; N]) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
      1.46.0 · source§
      impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for &[T]
      where
│ │ │ │ -    T: PartialEq<U>,
      source§
      fn eq(&self, other: &Vec<U, A>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
      source§
      fn ne(&self, other: &Vec<U, A>) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
      1.46.0 · source§
      impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for &mut [T]
      where
│ │ │ │ -    T: PartialEq<U>,
      source§
      fn eq(&self, other: &Vec<U, A>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
      source§
      fn ne(&self, other: &Vec<U, A>) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
      1.48.0 · source§
      impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for [T]
      where
│ │ │ │ -    T: PartialEq<U>,
      source§
      fn eq(&self, other: &Vec<U, A>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
      source§
      fn ne(&self, other: &Vec<U, A>) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
      source§
      impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for Cow<'_, [T]>
      where
│ │ │ │ -    T: PartialEq<U> + Clone,
      source§
      fn eq(&self, other: &Vec<U, A>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
      source§
      fn ne(&self, other: &Vec<U, A>) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
      1.17.0 · source§
      impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for VecDeque<T, A>
      where
│ │ │ │ -    T: PartialEq<U>,
      source§
      fn eq(&self, other: &Vec<U, A>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
      source§
      fn ne(&self, other: &Rhs) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
      source§
      impl<T, U, A1: Allocator, A2: Allocator> PartialEq<Vec<U, A2>> for Vec<T, A1>
      where
│ │ │ │ -    T: PartialEq<U>,
      source§
      fn eq(&self, other: &Vec<U, A2>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ -by ==.
      source§
      fn ne(&self, other: &Vec<U, A2>) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ -sufficient, and should not be overridden without very good reason.
      source§
      impl<T, A1, A2> PartialOrd<Vec<T, A2>> for Vec<T, A1>
      where
│ │ │ │ -    T: PartialOrd,
│ │ │ │ +
      §
      type Item = T
      The type of the elements being iterated over.
      §
      type IntoIter = IntoIter<T, A>
      Which kind of iterator are we turning this into?
      source§
      impl<T: Ord, A: Allocator> Ord for Vec<T, A>
      Implements ordering of vectors, lexicographically.
      
│ │ │ │ +
      source§
      fn cmp(&self, other: &Self) -> Ordering
      This method returns an Ordering between self and other. Read more
      1.21.0 · source§
      fn max(self, other: Self) -> Self
      where
│ │ │ │ +    Self: Sized,
      Compares and returns the maximum of two values. Read more
      1.21.0 · source§
      fn min(self, other: Self) -> Self
      where
│ │ │ │ +    Self: Sized,
      Compares and returns the minimum of two values. Read more
      1.50.0 · source§
      fn clamp(self, min: Self, max: Self) -> Self
      where
│ │ │ │ +    Self: Sized + PartialOrd,
      Restrict a value to a certain interval. Read more
      source§
      impl<T, U, A: Allocator> PartialEq<&[U]> for Vec<T, A>
      where
│ │ │ │ +    T: PartialEq<U>,
      source§
      fn eq(&self, other: &&[U]) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
      source§
      fn ne(&self, other: &&[U]) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
      source§
      impl<T, U, A: Allocator, const N: usize> PartialEq<&[U; N]> for Vec<T, A>
      where
│ │ │ │ +    T: PartialEq<U>,
      source§
      fn eq(&self, other: &&[U; N]) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
      source§
      fn ne(&self, other: &&[U; N]) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
      source§
      impl<T, U, A: Allocator> PartialEq<&mut [U]> for Vec<T, A>
      where
│ │ │ │ +    T: PartialEq<U>,
      source§
      fn eq(&self, other: &&mut [U]) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
      source§
      fn ne(&self, other: &&mut [U]) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
      1.48.0 · source§
      impl<T, U, A: Allocator> PartialEq<[U]> for Vec<T, A>
      where
│ │ │ │ +    T: PartialEq<U>,
      source§
      fn eq(&self, other: &[U]) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
      source§
      fn ne(&self, other: &[U]) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
      source§
      impl<T, U, A: Allocator, const N: usize> PartialEq<[U; N]> for Vec<T, A>
      where
│ │ │ │ +    T: PartialEq<U>,
      source§
      fn eq(&self, other: &[U; N]) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
      source§
      fn ne(&self, other: &[U; N]) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
      1.46.0 · source§
      impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for &[T]
      where
│ │ │ │ +    T: PartialEq<U>,
      source§
      fn eq(&self, other: &Vec<U, A>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
      source§
      fn ne(&self, other: &Vec<U, A>) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
      1.46.0 · source§
      impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for &mut [T]
      where
│ │ │ │ +    T: PartialEq<U>,
      source§
      fn eq(&self, other: &Vec<U, A>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
      source§
      fn ne(&self, other: &Vec<U, A>) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
      1.48.0 · source§
      impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for [T]
      where
│ │ │ │ +    T: PartialEq<U>,
      source§
      fn eq(&self, other: &Vec<U, A>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
      source§
      fn ne(&self, other: &Vec<U, A>) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
      source§
      impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for Cow<'_, [T]>
      where
│ │ │ │ +    T: PartialEq<U> + Clone,
      source§
      fn eq(&self, other: &Vec<U, A>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
      source§
      fn ne(&self, other: &Vec<U, A>) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
      1.17.0 · source§
      impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for VecDeque<T, A>
      where
│ │ │ │ +    T: PartialEq<U>,
      source§
      fn eq(&self, other: &Vec<U, A>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
      source§
      fn ne(&self, other: &Rhs) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
      source§
      impl<T, U, A1: Allocator, A2: Allocator> PartialEq<Vec<U, A2>> for Vec<T, A1>
      where
│ │ │ │ +    T: PartialEq<U>,
      source§
      fn eq(&self, other: &Vec<U, A2>) -> bool
      This method tests for self and other values to be equal, and is used
│ │ │ │ +by ==.
      source§
      fn ne(&self, other: &Vec<U, A2>) -> bool
      This method tests for !=. The default implementation is almost always
│ │ │ │ +sufficient, and should not be overridden without very good reason.
      source§
      impl<T, A1, A2> PartialOrd<Vec<T, A2>> for Vec<T, A1>
      where
│ │ │ │ +    T: PartialOrd,
│ │ │ │      A1: Allocator,
│ │ │ │ -    A2: Allocator,
      Implements comparison of vectors, lexicographically.
      
│ │ │ │ -
      source§
      fn partial_cmp(&self, other: &Vec<T, A2>) -> Option<Ordering>
      This method returns an ordering between self and other values if one exists. Read more
      source§
      fn lt(&self, other: &Rhs) -> bool
      This method tests less than (for self and other) and is used by the < operator. Read more
      source§
      fn le(&self, other: &Rhs) -> bool
      This method tests less than or equal to (for self and other) and is used by the <=
│ │ │ │ -operator. Read more
      source§
      fn gt(&self, other: &Rhs) -> bool
      This method tests greater than (for self and other) and is used by the > operator. Read more
      source§
      fn ge(&self, other: &Rhs) -> bool
      This method tests greater than or equal to (for self and other) and is used by the >=
│ │ │ │ -operator. Read more
      1.66.0 · source§
      impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]>
      source§
      fn try_from(vec: Vec<T>) -> Result<Self, Self::Error>
      Attempts to convert a Vec<T> into a Box<[T; N]>.
      
│ │ │ │ +    A2: Allocator,
      Implements comparison of vectors, lexicographically.
      
│ │ │ │ +
      source§
      fn partial_cmp(&self, other: &Vec<T, A2>) -> Option<Ordering>
      This method returns an ordering between self and other values if one exists. Read more
      source§
      fn lt(&self, other: &Rhs) -> bool
      This method tests less than (for self and other) and is used by the < operator. Read more
      source§
      fn le(&self, other: &Rhs) -> bool
      This method tests less than or equal to (for self and other) and is used by the <=
│ │ │ │ +operator. Read more
      source§
      fn gt(&self, other: &Rhs) -> bool
      This method tests greater than (for self and other) and is used by the > operator. Read more
      source§
      fn ge(&self, other: &Rhs) -> bool
      This method tests greater than or equal to (for self and other) and is used by the >=
│ │ │ │ +operator. Read more
      1.66.0 · source§
      impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]>
      source§
      fn try_from(vec: Vec<T>) -> Result<Self, Self::Error>
      Attempts to convert a Vec<T> into a Box<[T; N]>.
      
│ │ │ │  
      Like Vec::into_boxed_slice, this is in-place if vec.capacity() == N,
│ │ │ │  but will require a reallocation otherwise.
      
│ │ │ │  
      §Errors
      
│ │ │ │  
      Returns the original Vec<T> in the Err variant if
│ │ │ │  boxed_slice.len() does not equal N.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      This can be used with vec! to create an array on the heap:
      
│ │ │ │  
│ │ │ │  
      let state: Box<[f32; 100]> = vec![1.0; 100].try_into().unwrap();
│ │ │ │  assert_eq!(state.len(), 100);
      Run
      
│ │ │ │ -
      §
      type Error = Vec<T>
      The type returned in the event of a conversion error.
      1.48.0 · source§
      impl<T, A: Allocator, const N: usize> TryFrom<Vec<T, A>> for [T; N]
      source§
      fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>
      Gets the entire contents of the Vec<T> as an array,
│ │ │ │ +
      §
      type Error = Vec<T>
      The type returned in the event of a conversion error.
      1.48.0 · source§
      impl<T, A: Allocator, const N: usize> TryFrom<Vec<T, A>> for [T; N]
      source§
      fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>
      Gets the entire contents of the Vec<T> as an array,
│ │ │ │  if its size exactly matches that of the requested array.
      
│ │ │ │  
      §Examples
      
│ │ │ │  
      assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));
│ │ │ │  assert_eq!(<Vec<i32>>::new().try_into(), Ok([]));
      Run
      
│ │ │ │  
      If the length doesn’t match, the input comes back in Err:
      
│ │ │ │  
│ │ │ │  
      let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();
│ │ │ │ @@ -3860,30 +3860,30 @@
│ │ │ │  
│ │ │ │  
      let mut v = String::from("hello world").into_bytes();
│ │ │ │  v.sort();
│ │ │ │  v.truncate(2);
│ │ │ │  let [a, b]: [_; 2] = v.try_into().unwrap();
│ │ │ │  assert_eq!(a, b' ');
│ │ │ │  assert_eq!(b, b'd');
      Run
      
│ │ │ │ -
      §
      type Error = Vec<T, A>
      The type returned in the event of a conversion error.
      source§
      impl<T: Eq, A: Allocator> Eq for Vec<T, A>
      Auto Trait Implementations§
      §
      impl<T, A> Freeze for Vec<T, A>
      where
│ │ │ │ -    A: Freeze,
      §
      impl<T, A> RefUnwindSafe for Vec<T, A>
      where
│ │ │ │ -    A: RefUnwindSafe,
│ │ │ │ -    T: RefUnwindSafe,
      §
      impl<T, A> Send for Vec<T, A>
      where
│ │ │ │ -    A: Send,
│ │ │ │ -    T: Send,
      §
      impl<T, A> Sync for Vec<T, A>
      where
│ │ │ │ -    A: Sync,
│ │ │ │ -    T: Sync,
      §
      impl<T, A> Unpin for Vec<T, A>
      where
│ │ │ │ -    A: Unpin,
│ │ │ │ -    T: Unpin,
      §
      impl<T, A> UnwindSafe for Vec<T, A>
      where
│ │ │ │ -    A: UnwindSafe,
│ │ │ │ -    T: UnwindSafe,
      Blanket Implementations§
      source§
      impl<T> Any for T
      where
│ │ │ │ -    T: 'static + ?Sized,
      source§
      fn type_id(&self) -> TypeId
      Gets the TypeId of self. Read more
      source§
      impl<T> Borrow<T> for T
      where
│ │ │ │ -    T: ?Sized,
      source§
      fn borrow(&self) -> &T
      Immutably borrows from an owned value. Read more
      source§
      impl<T> BorrowMut<T> for T
      where
│ │ │ │ -    T: ?Sized,
      source§
      fn borrow_mut(&mut self) -> &mut T
      Mutably borrows from an owned value. Read more
      source§
      impl<T> From<T> for T
      source§
      fn from(t: T) -> T
      Returns the argument unchanged.
      
│ │ │ │ -
      source§
      impl<T, U> Into<U> for T
      where
│ │ │ │ -    U: From<T>,
      source§
      fn into(self) -> U
      Calls U::from(self).
      
│ │ │ │ +
      §
      type Error = Vec<T, A>
      The type returned in the event of a conversion error.
      source§
      impl<T: Eq, A: Allocator> Eq for Vec<T, A>
      Auto Trait Implementations§
      §
      impl<T, A> Freeze for Vec<T, A>
      where
│ │ │ │ +    A: Freeze,
      §
      impl<T, A> RefUnwindSafe for Vec<T, A>
      where
│ │ │ │ +    A: RefUnwindSafe,
│ │ │ │ +    T: RefUnwindSafe,
      §
      impl<T, A> Send for Vec<T, A>
      where
│ │ │ │ +    A: Send,
│ │ │ │ +    T: Send,
      §
      impl<T, A> Sync for Vec<T, A>
      where
│ │ │ │ +    A: Sync,
│ │ │ │ +    T: Sync,
      §
      impl<T, A> Unpin for Vec<T, A>
      where
│ │ │ │ +    A: Unpin,
│ │ │ │ +    T: Unpin,
      §
      impl<T, A> UnwindSafe for Vec<T, A>
      where
│ │ │ │ +    A: UnwindSafe,
│ │ │ │ +    T: UnwindSafe,
      Blanket Implementations§
      source§
      impl<T> Any for T
      where
│ │ │ │ +    T: 'static + ?Sized,
      source§
      fn type_id(&self) -> TypeId
      Gets the TypeId of self. Read more
      source§
      impl<T> Borrow<T> for T
      where
│ │ │ │ +    T: ?Sized,
      source§
      fn borrow(&self) -> &T
      Immutably borrows from an owned value. Read more
      source§
      impl<T> BorrowMut<T> for T
      where
│ │ │ │ +    T: ?Sized,
      source§
      fn borrow_mut(&mut self) -> &mut T
      Mutably borrows from an owned value. Read more
      source§
      impl<T> From<T> for T
      source§
      fn from(t: T) -> T
      Returns the argument unchanged.
      
│ │ │ │ +
      source§
      impl<T, U> Into<U> for T
      where
│ │ │ │ +    U: From<T>,
      source§
      fn into(self) -> U
      Calls U::from(self).
      
│ │ │ │  
      That is, this conversion is whatever the implementation of
│ │ │ │ -From<T> for U chooses to do.
      
│ │ │ │ +From<T> for U chooses to do.
      
│ │ │ │  
      source§
      impl<T> ToOwned for T
      where
│ │ │ │ -    T: Clone,
      §
      type Owned = T
      The resulting type after obtaining ownership.
      source§
      fn to_owned(&self) -> T
      Creates owned data from borrowed data, usually by cloning. Read more
      source§
      fn clone_into(&self, target: &mut T)
      Uses borrowed data to replace owned data, usually by cloning. Read more
      source§
      impl<T, U> TryFrom<U> for T
      where
│ │ │ │ -    U: Into<T>,
      §
      type Error = Infallible
      The type returned in the event of a conversion error.
      source§
      fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
      Performs the conversion.
      source§
      impl<T, U> TryInto<U> for T
      where
│ │ │ │ -    U: TryFrom<T>,
      §
      type Error = <U as TryFrom<T>>::Error
      The type returned in the event of a conversion error.
      source§
      fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
      Performs the conversion.
      
│ │ │ │ +    T: Clone,
      §
      type Owned = T
      The resulting type after obtaining ownership.
      source§
      fn to_owned(&self) -> T
      Creates owned data from borrowed data, usually by cloning. Read more
      source§
      fn clone_into(&self, target: &mut T)
      Uses borrowed data to replace owned data, usually by cloning. Read more
      source§
      impl<T, U> TryFrom<U> for T
      where
│ │ │ │ +    U: Into<T>,
      §
      type Error = Infallible
      The type returned in the event of a conversion error.
      source§
      fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
      Performs the conversion.
      source§
      impl<T, U> TryInto<U> for T
      where
│ │ │ │ +    U: TryFrom<T>,
      §
      type Error = <U as TryFrom<T>>::Error
      The type returned in the event of a conversion error.
      source§
      fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
      Performs the conversion.
      
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/async_iter/async_iter/trait.AsyncIterator.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<S: ?Sized + AsyncIterator + Unpin> AsyncIterator for Box<S>"]
│ │ │ │ │ +            ["impl<S: ?Sized + AsyncIterator + Unpin> AsyncIterator for Box<S>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/borrow/trait.Borrow.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,17 +1,17 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Borrow<str> for String"],
│ │ │ │ │ -            ["impl Borrow<CStr> for CString"],
│ │ │ │ │ -            ["impl<'a, B> Borrow<B> for Cow<'a, B>
      where\n    B: ToOwned + ?Sized,
      "],
│ │ │ │ │ -            ["impl<T, A: Allocator> Borrow<[T]> for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Borrow<T> for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Borrow<T> for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Borrow<T> for Arc<T, A>"]
│ │ │ │ │ +            ["impl Borrow<str> for String"],
│ │ │ │ │ +            ["impl Borrow<CStr> for CString"],
│ │ │ │ │ +            ["impl<'a, B> Borrow<B> for Cow<'a, B>
      where\n    B: ToOwned + ?Sized,
      "],
│ │ │ │ │ +            ["impl<T, A: Allocator> Borrow<[T]> for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Borrow<T> for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Borrow<T> for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Borrow<T> for Arc<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl Borrow<OsStr> for OsString"],
│ │ │ │ │              ["impl Borrow<Path> for PathBuf"]
│ │ │ │ │          ]
│ │ │ │ │      };
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/borrow/trait.BorrowMut.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,13 +1,13 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl BorrowMut<str> for String"],
│ │ │ │ │ -            ["impl<T, A: Allocator> BorrowMut<[T]> for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> BorrowMut<T> for Box<T, A>"]
│ │ │ │ │ +            ["impl BorrowMut<str> for String"],
│ │ │ │ │ +            ["impl<T, A: Allocator> BorrowMut<[T]> for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> BorrowMut<T> for Box<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/clone/trait.Clone.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,55 +1,55 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Clone for TryReserveErrorKind"],
│ │ │ │ │ -            ["impl Clone for Global"],
│ │ │ │ │ -            ["impl Clone for Box<str>"],
│ │ │ │ │ -            ["impl Clone for Box<CStr>"],
│ │ │ │ │ -            ["impl Clone for UnorderedKeyError"],
│ │ │ │ │ -            ["impl Clone for TryReserveError"],
│ │ │ │ │ -            ["impl Clone for FromVecWithNulError"],
│ │ │ │ │ -            ["impl Clone for IntoStringError"],
│ │ │ │ │ -            ["impl Clone for NulError"],
│ │ │ │ │ -            ["impl Clone for CString"],
│ │ │ │ │ -            ["impl Clone for FromUtf8Error"],
│ │ │ │ │ -            ["impl Clone for String"],
│ │ │ │ │ -            ["impl<B: ?Sized + ToOwned> Clone for Cow<'_, B>"],
│ │ │ │ │ -            ["impl<K, V> Clone for Cursor<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> Clone for Iter<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> Clone for Keys<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> Clone for Range<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> Clone for Values<'_, K, V>"],
│ │ │ │ │ -            ["impl<K: Clone, V: Clone, A: Allocator + Clone> Clone for BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<T> Clone for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> Clone for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> Clone for Range<'_, T>"],
│ │ │ │ │ -            ["impl<T> Clone for SymmetricDifference<'_, T>"],
│ │ │ │ │ -            ["impl<T> Clone for Union<'_, T>"],
│ │ │ │ │ -            ["impl<T> Clone for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> Clone for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T, A: Allocator + Clone> Clone for Difference<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator + Clone> Clone for Intersection<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Clone for Cursor<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Allocator + Clone> Clone for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Allocator + Clone> Clone for BinaryHeap<T, A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Allocator + Clone> Clone for BTreeSet<T, A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Allocator + Clone> Clone for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Allocator + Clone> Clone for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Clone + Allocator> Clone for IntoIterSorted<T, A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator + Clone> Clone for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator + Clone> Clone for Weak<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator + Clone> Clone for Arc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator + Clone> Clone for Weak<T, A>"]
│ │ │ │ │ +            ["impl Clone for TryReserveErrorKind"],
│ │ │ │ │ +            ["impl Clone for Global"],
│ │ │ │ │ +            ["impl Clone for Box<str>"],
│ │ │ │ │ +            ["impl Clone for Box<CStr>"],
│ │ │ │ │ +            ["impl Clone for UnorderedKeyError"],
│ │ │ │ │ +            ["impl Clone for TryReserveError"],
│ │ │ │ │ +            ["impl Clone for FromVecWithNulError"],
│ │ │ │ │ +            ["impl Clone for IntoStringError"],
│ │ │ │ │ +            ["impl Clone for NulError"],
│ │ │ │ │ +            ["impl Clone for CString"],
│ │ │ │ │ +            ["impl Clone for FromUtf8Error"],
│ │ │ │ │ +            ["impl Clone for String"],
│ │ │ │ │ +            ["impl<B: ?Sized + ToOwned> Clone for Cow<'_, B>"],
│ │ │ │ │ +            ["impl<K, V> Clone for Cursor<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> Clone for Iter<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> Clone for Keys<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> Clone for Range<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> Clone for Values<'_, K, V>"],
│ │ │ │ │ +            ["impl<K: Clone, V: Clone, A: Allocator + Clone> Clone for BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<T> Clone for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> Clone for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> Clone for Range<'_, T>"],
│ │ │ │ │ +            ["impl<T> Clone for SymmetricDifference<'_, T>"],
│ │ │ │ │ +            ["impl<T> Clone for Union<'_, T>"],
│ │ │ │ │ +            ["impl<T> Clone for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> Clone for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T, A: Allocator + Clone> Clone for Difference<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator + Clone> Clone for Intersection<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Clone for Cursor<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Allocator + Clone> Clone for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Allocator + Clone> Clone for BinaryHeap<T, A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Allocator + Clone> Clone for BTreeSet<T, A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Allocator + Clone> Clone for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Allocator + Clone> Clone for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Clone + Allocator> Clone for IntoIterSorted<T, A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T: Clone, A: Clone + Allocator> Clone for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator + Clone> Clone for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator + Clone> Clone for Weak<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator + Clone> Clone for Arc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator + Clone> Clone for Weak<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl Clone for Delimiter"],
│ │ │ │ │              ["impl Clone for Level"],
│ │ │ │ │              ["impl Clone for Spacing"],
│ │ │ │ │              ["impl Clone for TokenTree"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.Eq.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,28 +1,28 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Eq for TryReserveErrorKind"],
│ │ │ │ │ -            ["impl Eq for UnorderedKeyError"],
│ │ │ │ │ -            ["impl Eq for TryReserveError"],
│ │ │ │ │ -            ["impl Eq for FromVecWithNulError"],
│ │ │ │ │ -            ["impl Eq for IntoStringError"],
│ │ │ │ │ -            ["impl Eq for NulError"],
│ │ │ │ │ -            ["impl Eq for CString"],
│ │ │ │ │ -            ["impl Eq for FromUtf8Error"],
│ │ │ │ │ -            ["impl Eq for String"],
│ │ │ │ │ -            ["impl<B> Eq for Cow<'_, B>
      where\n    B: Eq + ToOwned + ?Sized,
      "],
│ │ │ │ │ -            ["impl<K: Eq, V: Eq, A: Allocator + Clone> Eq for BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<T: Eq, A: Allocator + Clone> Eq for BTreeSet<T, A>"],
│ │ │ │ │ -            ["impl<T: Eq, A: Allocator> Eq for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<T: Eq, A: Allocator> Eq for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T: Eq, A: Allocator> Eq for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Eq, A: Allocator> Eq for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Eq, A: Allocator> Eq for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Eq, A: Allocator> Eq for Arc<T, A>"]
│ │ │ │ │ +            ["impl Eq for TryReserveErrorKind"],
│ │ │ │ │ +            ["impl Eq for UnorderedKeyError"],
│ │ │ │ │ +            ["impl Eq for TryReserveError"],
│ │ │ │ │ +            ["impl Eq for FromVecWithNulError"],
│ │ │ │ │ +            ["impl Eq for IntoStringError"],
│ │ │ │ │ +            ["impl Eq for NulError"],
│ │ │ │ │ +            ["impl Eq for CString"],
│ │ │ │ │ +            ["impl Eq for FromUtf8Error"],
│ │ │ │ │ +            ["impl Eq for String"],
│ │ │ │ │ +            ["impl<B> Eq for Cow<'_, B>
      where\n    B: Eq + ToOwned + ?Sized,
      "],
│ │ │ │ │ +            ["impl<K: Eq, V: Eq, A: Allocator + Clone> Eq for BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<T: Eq, A: Allocator + Clone> Eq for BTreeSet<T, A>"],
│ │ │ │ │ +            ["impl<T: Eq, A: Allocator> Eq for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<T: Eq, A: Allocator> Eq for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T: Eq, A: Allocator> Eq for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Eq, A: Allocator> Eq for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Eq, A: Allocator> Eq for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Eq, A: Allocator> Eq for Arc<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl Eq for Delimiter"],
│ │ │ │ │              ["impl Eq for Spacing"],
│ │ │ │ │              ["impl Eq for SourceFile"]
│ │ │ │ │          ],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.Ord.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,21 +1,21 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Ord for CString"],
│ │ │ │ │ -            ["impl Ord for String"],
│ │ │ │ │ -            ["impl<B> Ord for Cow<'_, B>
      where\n    B: Ord + ToOwned + ?Sized,
      "],
│ │ │ │ │ -            ["impl<K: Ord, V: Ord, A: Allocator + Clone> Ord for BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator + Clone> Ord for BTreeSet<T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> Ord for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> Ord for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> Ord for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Ord, A: Allocator> Ord for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Ord, A: Allocator> Ord for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Ord, A: Allocator> Ord for Arc<T, A>"]
│ │ │ │ │ +            ["impl Ord for CString"],
│ │ │ │ │ +            ["impl Ord for String"],
│ │ │ │ │ +            ["impl<B> Ord for Cow<'_, B>
      where\n    B: Ord + ToOwned + ?Sized,
      "],
│ │ │ │ │ +            ["impl<K: Ord, V: Ord, A: Allocator + Clone> Ord for BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator + Clone> Ord for BTreeSet<T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> Ord for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> Ord for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> Ord for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Ord, A: Allocator> Ord for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Ord, A: Allocator> Ord for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Ord, A: Allocator> Ord for Arc<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl Ord for ErrorKind"],
│ │ │ │ │              ["impl Ord for OsStr"],
│ │ │ │ │              ["impl Ord for OsString"],
│ │ │ │ │              ["impl Ord for Components<'_>"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.PartialEq.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,55 +1,55 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl PartialEq for TryReserveErrorKind"],
│ │ │ │ │ -            ["impl PartialEq for UnorderedKeyError"],
│ │ │ │ │ -            ["impl PartialEq for TryReserveError"],
│ │ │ │ │ -            ["impl PartialEq for FromVecWithNulError"],
│ │ │ │ │ -            ["impl PartialEq for IntoStringError"],
│ │ │ │ │ -            ["impl PartialEq for NulError"],
│ │ │ │ │ -            ["impl PartialEq for CString"],
│ │ │ │ │ -            ["impl PartialEq for FromUtf8Error"],
│ │ │ │ │ -            ["impl PartialEq for String"],
│ │ │ │ │ -            ["impl<'a, 'b> PartialEq<&'a str> for String"],
│ │ │ │ │ -            ["impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>"],
│ │ │ │ │ -            ["impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str"],
│ │ │ │ │ -            ["impl<'a, 'b> PartialEq<Cow<'a, str>> for str"],
│ │ │ │ │ -            ["impl<'a, 'b> PartialEq<Cow<'a, str>> for String"],
│ │ │ │ │ -            ["impl<'a, 'b> PartialEq<str> for Cow<'a, str>"],
│ │ │ │ │ -            ["impl<'a, 'b> PartialEq<str> for String"],
│ │ │ │ │ -            ["impl<'a, 'b> PartialEq<String> for &'a str"],
│ │ │ │ │ -            ["impl<'a, 'b> PartialEq<String> for Cow<'a, str>"],
│ │ │ │ │ -            ["impl<'a, 'b> PartialEq<String> for str"],
│ │ │ │ │ -            ["impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B>
      where\n    B: PartialEq<C> + ToOwned + ?Sized,\n    C: ToOwned + ?Sized,
      "],
│ │ │ │ │ -            ["impl<K: PartialEq, V: PartialEq, A: Allocator + Clone> PartialEq for BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<T, U> PartialEq<&[U]> for Cow<'_, [T]>
      where\n    T: PartialEq<U> + Clone,
      "],
│ │ │ │ │ -            ["impl<T, U> PartialEq<&mut [U]> for Cow<'_, [T]>
      where\n    T: PartialEq<U> + Clone,
      "],
│ │ │ │ │ -            ["impl<T, U, A1: Allocator, A2: Allocator> PartialEq<Vec<U, A2>> for Vec<T, A1>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator> PartialEq<&[U]> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator> PartialEq<&[U]> for Vec<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator> PartialEq<&mut [U]> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator> PartialEq<&mut [U]> for Vec<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator> PartialEq<[U]> for Vec<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for &[T]
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for &mut [T]
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for Cow<'_, [T]>
      where\n    T: PartialEq<U> + Clone,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for [T]
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator, const N: usize> PartialEq<&[U; N]> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator, const N: usize> PartialEq<&[U; N]> for Vec<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator, const N: usize> PartialEq<&mut [U; N]> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator, const N: usize> PartialEq<[U; N]> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T, U, A: Allocator, const N: usize> PartialEq<[U; N]> for Vec<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ -            ["impl<T: PartialEq, A: Allocator + Clone> PartialEq for BTreeSet<T, A>"],
│ │ │ │ │ -            ["impl<T: PartialEq, A: Allocator> PartialEq for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<T: PartialEq, A: Allocator> PartialEq for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Arc<T, A>"]
│ │ │ │ │ +            ["impl PartialEq for TryReserveErrorKind"],
│ │ │ │ │ +            ["impl PartialEq for UnorderedKeyError"],
│ │ │ │ │ +            ["impl PartialEq for TryReserveError"],
│ │ │ │ │ +            ["impl PartialEq for FromVecWithNulError"],
│ │ │ │ │ +            ["impl PartialEq for IntoStringError"],
│ │ │ │ │ +            ["impl PartialEq for NulError"],
│ │ │ │ │ +            ["impl PartialEq for CString"],
│ │ │ │ │ +            ["impl PartialEq for FromUtf8Error"],
│ │ │ │ │ +            ["impl PartialEq for String"],
│ │ │ │ │ +            ["impl<'a, 'b> PartialEq<&'a str> for String"],
│ │ │ │ │ +            ["impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>"],
│ │ │ │ │ +            ["impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str"],
│ │ │ │ │ +            ["impl<'a, 'b> PartialEq<Cow<'a, str>> for str"],
│ │ │ │ │ +            ["impl<'a, 'b> PartialEq<Cow<'a, str>> for String"],
│ │ │ │ │ +            ["impl<'a, 'b> PartialEq<str> for Cow<'a, str>"],
│ │ │ │ │ +            ["impl<'a, 'b> PartialEq<str> for String"],
│ │ │ │ │ +            ["impl<'a, 'b> PartialEq<String> for &'a str"],
│ │ │ │ │ +            ["impl<'a, 'b> PartialEq<String> for Cow<'a, str>"],
│ │ │ │ │ +            ["impl<'a, 'b> PartialEq<String> for str"],
│ │ │ │ │ +            ["impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B>
      where\n    B: PartialEq<C> + ToOwned + ?Sized,\n    C: ToOwned + ?Sized,
      "],
│ │ │ │ │ +            ["impl<K: PartialEq, V: PartialEq, A: Allocator + Clone> PartialEq for BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<T, U> PartialEq<&[U]> for Cow<'_, [T]>
      where\n    T: PartialEq<U> + Clone,
      "],
│ │ │ │ │ +            ["impl<T, U> PartialEq<&mut [U]> for Cow<'_, [T]>
      where\n    T: PartialEq<U> + Clone,
      "],
│ │ │ │ │ +            ["impl<T, U, A1: Allocator, A2: Allocator> PartialEq<Vec<U, A2>> for Vec<T, A1>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator> PartialEq<&[U]> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator> PartialEq<&[U]> for Vec<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator> PartialEq<&mut [U]> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator> PartialEq<&mut [U]> for Vec<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator> PartialEq<[U]> for Vec<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for &[T]
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for &mut [T]
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for Cow<'_, [T]>
      where\n    T: PartialEq<U> + Clone,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for [T]
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator, const N: usize> PartialEq<&[U; N]> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator, const N: usize> PartialEq<&[U; N]> for Vec<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator, const N: usize> PartialEq<&mut [U; N]> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator, const N: usize> PartialEq<[U; N]> for VecDeque<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T, U, A: Allocator, const N: usize> PartialEq<[U; N]> for Vec<T, A>
      where\n    T: PartialEq<U>,
      "],
│ │ │ │ │ +            ["impl<T: PartialEq, A: Allocator + Clone> PartialEq for BTreeSet<T, A>"],
│ │ │ │ │ +            ["impl<T: PartialEq, A: Allocator> PartialEq for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<T: PartialEq, A: Allocator> PartialEq for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for Arc<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl PartialEq for Delimiter"],
│ │ │ │ │              ["impl PartialEq for Spacing"],
│ │ │ │ │              ["impl PartialEq for SourceFile"],
│ │ │ │ │              ["impl PartialEq<char> for Punct"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/cmp/trait.PartialOrd.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,21 +1,21 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl PartialOrd for CString"],
│ │ │ │ │ -            ["impl PartialOrd for String"],
│ │ │ │ │ -            ["impl<'a, B> PartialOrd for Cow<'a, B>
      where\n    B: PartialOrd + ToOwned + ?Sized,
      "],
│ │ │ │ │ -            ["impl<K: PartialOrd, V: PartialOrd, A: Allocator + Clone> PartialOrd for BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<T, A1, A2> PartialOrd<Vec<T, A2>> for Vec<T, A1>
      where\n    T: PartialOrd,\n    A1: Allocator,\n    A2: Allocator,
      "],
│ │ │ │ │ -            ["impl<T: PartialOrd, A: Allocator + Clone> PartialOrd for BTreeSet<T, A>"],
│ │ │ │ │ -            ["impl<T: PartialOrd, A: Allocator> PartialOrd for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<T: PartialOrd, A: Allocator> PartialOrd for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Arc<T, A>"]
│ │ │ │ │ +            ["impl PartialOrd for CString"],
│ │ │ │ │ +            ["impl PartialOrd for String"],
│ │ │ │ │ +            ["impl<'a, B> PartialOrd for Cow<'a, B>
      where\n    B: PartialOrd + ToOwned + ?Sized,
      "],
│ │ │ │ │ +            ["impl<K: PartialOrd, V: PartialOrd, A: Allocator + Clone> PartialOrd for BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<T, A1, A2> PartialOrd<Vec<T, A2>> for Vec<T, A1>
      where\n    T: PartialOrd,\n    A1: Allocator,\n    A2: Allocator,
      "],
│ │ │ │ │ +            ["impl<T: PartialOrd, A: Allocator + Clone> PartialOrd for BTreeSet<T, A>"],
│ │ │ │ │ +            ["impl<T: PartialOrd, A: Allocator> PartialOrd for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<T: PartialOrd, A: Allocator> PartialOrd for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + PartialOrd, A: Allocator> PartialOrd for Arc<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl PartialOrd for ErrorKind"],
│ │ │ │ │              ["impl PartialOrd for OsStr"],
│ │ │ │ │              ["impl PartialOrd for OsString"],
│ │ │ │ │              ["impl PartialOrd for Path"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.AsMut.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,14 +1,14 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl AsMut<str> for String"],
│ │ │ │ │ -            ["impl<T, A: Allocator> AsMut<[T]> for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> AsMut<Vec<T, A>> for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> AsMut<T> for Box<T, A>"]
│ │ │ │ │ +            ["impl AsMut<str> for String"],
│ │ │ │ │ +            ["impl<T, A: Allocator> AsMut<[T]> for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> AsMut<Vec<T, A>> for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> AsMut<T> for Box<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.AsRef.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,23 +1,23 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl AsRef<str> for String"],
│ │ │ │ │ -            ["impl AsRef<CStr> for CString"],
│ │ │ │ │ -            ["impl AsRef<[u8]> for String"],
│ │ │ │ │ -            ["impl<'a> AsRef<str> for Drain<'a>"],
│ │ │ │ │ -            ["impl<'a> AsRef<[u8]> for Drain<'a>"],
│ │ │ │ │ -            ["impl<'a, T, A: Allocator> AsRef<[T]> for Drain<'a, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> AsRef<[T]> for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> AsRef<[T]> for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> AsRef<Vec<T, A>> for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + ToOwned> AsRef<T> for Cow<'_, T>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> AsRef<T> for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> AsRef<T> for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> AsRef<T> for Arc<T, A>"]
│ │ │ │ │ +            ["impl AsRef<str> for String"],
│ │ │ │ │ +            ["impl AsRef<CStr> for CString"],
│ │ │ │ │ +            ["impl AsRef<[u8]> for String"],
│ │ │ │ │ +            ["impl<'a> AsRef<str> for Drain<'a>"],
│ │ │ │ │ +            ["impl<'a> AsRef<[u8]> for Drain<'a>"],
│ │ │ │ │ +            ["impl<'a, T, A: Allocator> AsRef<[T]> for Drain<'a, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> AsRef<[T]> for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> AsRef<[T]> for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> AsRef<Vec<T, A>> for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + ToOwned> AsRef<T> for Cow<'_, T>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> AsRef<T> for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> AsRef<T> for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> AsRef<T> for Arc<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl AsRef<OsStr> for Component<'_>"],
│ │ │ │ │              ["impl AsRef<OsStr> for str"],
│ │ │ │ │              ["impl AsRef<OsStr> for OsStr"],
│ │ │ │ │              ["impl AsRef<OsStr> for OsString"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.From.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,98 +1,98 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl From<&str> for Box<str>"],
│ │ │ │ │ -            ["impl From<&str> for Rc<str>"],
│ │ │ │ │ -            ["impl From<&str> for String"],
│ │ │ │ │ -            ["impl From<&str> for Arc<str>"],
│ │ │ │ │ -            ["impl From<&str> for Vec<u8>"],
│ │ │ │ │ -            ["impl From<&String> for String"],
│ │ │ │ │ -            ["impl From<&CStr> for Box<CStr>"],
│ │ │ │ │ -            ["impl From<&CStr> for CString"],
│ │ │ │ │ -            ["impl From<&CStr> for Rc<CStr>"],
│ │ │ │ │ -            ["impl From<&CStr> for Arc<CStr>"],
│ │ │ │ │ -            ["impl From<&mut str> for String"],
│ │ │ │ │ -            ["impl From<Cow<'_, str>> for Box<str>"],
│ │ │ │ │ -            ["impl From<Cow<'_, CStr>> for Box<CStr>"],
│ │ │ │ │ -            ["impl From<TryReserveErrorKind> for TryReserveError"],
│ │ │ │ │ -            ["impl From<char> for String"],
│ │ │ │ │ -            ["impl From<LayoutError> for TryReserveErrorKind"],
│ │ │ │ │ -            ["impl From<Box<str>> for String"],
│ │ │ │ │ -            ["impl From<Box<CStr>> for CString"],
│ │ │ │ │ -            ["impl From<CString> for Box<CStr>"],
│ │ │ │ │ -            ["impl From<CString> for Rc<CStr>"],
│ │ │ │ │ -            ["impl From<CString> for Arc<CStr>"],
│ │ │ │ │ -            ["impl From<CString> for Vec<u8>"],
│ │ │ │ │ -            ["impl From<Rc<str>> for Rc<[u8]>"],
│ │ │ │ │ -            ["impl From<String> for Box<str>"],
│ │ │ │ │ -            ["impl From<String> for Rc<str>"],
│ │ │ │ │ -            ["impl From<String> for Arc<str>"],
│ │ │ │ │ -            ["impl From<String> for Vec<u8>"],
│ │ │ │ │ -            ["impl From<Arc<str>> for Arc<[u8]>"],
│ │ │ │ │ -            ["impl From<Vec<NonZero<u8>>> for CString"],
│ │ │ │ │ -            ["impl<'a> From<&'a str> for Cow<'a, str>"],
│ │ │ │ │ -            ["impl<'a> From<&'a CString> for Cow<'a, CStr>"],
│ │ │ │ │ -            ["impl<'a> From<&'a String> for Cow<'a, str>"],
│ │ │ │ │ -            ["impl<'a> From<&'a CStr> for Cow<'a, CStr>"],
│ │ │ │ │ -            ["impl<'a> From<&str> for Box<dyn Error + 'a>"],
│ │ │ │ │ -            ["impl<'a> From<&str> for Box<dyn Error + Send + Sync + 'a>"],
│ │ │ │ │ -            ["impl<'a> From<Cow<'a, str>> for String"],
│ │ │ │ │ -            ["impl<'a> From<Cow<'a, CStr>> for CString"],
│ │ │ │ │ -            ["impl<'a> From<CString> for Cow<'a, CStr>"],
│ │ │ │ │ -            ["impl<'a> From<String> for Cow<'a, str>"],
│ │ │ │ │ -            ["impl<'a> From<String> for Box<dyn Error + 'a>"],
│ │ │ │ │ -            ["impl<'a> From<String> for Box<dyn Error + Send + Sync + 'a>"],
│ │ │ │ │ -            ["impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a>"],
│ │ │ │ │ -            ["impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>"],
│ │ │ │ │ -            ["impl<'a, B> From<Cow<'a, B>> for Rc<B>
      where\n    B: ToOwned + ?Sized,\n    Rc<B>: From<&'a B> + From<B::Owned>,
      "],
│ │ │ │ │ -            ["impl<'a, B> From<Cow<'a, B>> for Arc<B>
      where\n    B: ToOwned + ?Sized,\n    Arc<B>: From<&'a B> + From<B::Owned>,
      "],
│ │ │ │ │ -            ["impl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a>"],
│ │ │ │ │ -            ["impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a>"],
│ │ │ │ │ -            ["impl<'a, T> From<Cow<'a, [T]>> for Vec<T>
      where\n    [T]: ToOwned<Owned = Vec<T>>,
      "],
│ │ │ │ │ -            ["impl<'a, T: Clone> From<&'a [T]> for Cow<'a, [T]>"],
│ │ │ │ │ -            ["impl<'a, T: Clone> From<&'a Vec<T>> for Cow<'a, [T]>"],
│ │ │ │ │ -            ["impl<'a, T: Clone> From<Vec<T>> for Cow<'a, [T]>"],
│ │ │ │ │ -            ["impl<'a, T: Clone, const N: usize> From<&'a [T; N]> for Cow<'a, [T]>"],
│ │ │ │ │ -            ["impl<A: Allocator> From<Box<str, A>> for Box<[u8], A>"],
│ │ │ │ │ -            ["impl<K: Ord, V, const N: usize> From<[(K, V); N]> for BTreeMap<K, V>"],
│ │ │ │ │ -            ["impl<T> From<T> for Box<T>"],
│ │ │ │ │ -            ["impl<T> From<T> for Rc<T>"],
│ │ │ │ │ -            ["impl<T> From<T> for Arc<T>"],
│ │ │ │ │ -            ["impl<T, A: Allocator + Clone> From<Vec<T, A>> for Arc<[T], A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> From<BinaryHeap<T, A>> for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> From<Vec<T, A>> for Rc<[T], A>"],
│ │ │ │ │ -            ["impl<T, const N: usize> From<[T; N]> for Box<[T]>"],
│ │ │ │ │ -            ["impl<T, const N: usize> From<[T; N]> for LinkedList<T>"],
│ │ │ │ │ -            ["impl<T, const N: usize> From<[T; N]> for VecDeque<T>"],
│ │ │ │ │ -            ["impl<T, const N: usize> From<[T; N]> for Rc<[T]>"],
│ │ │ │ │ -            ["impl<T, const N: usize> From<[T; N]> for Arc<[T]>"],
│ │ │ │ │ -            ["impl<T, const N: usize> From<[T; N]> for Vec<T>"],
│ │ │ │ │ -            ["impl<T: Clone> From<&[T]> for Box<[T]>"],
│ │ │ │ │ -            ["impl<T: Clone> From<&[T]> for Rc<[T]>"],
│ │ │ │ │ -            ["impl<T: Clone> From<&[T]> for Arc<[T]>"],
│ │ │ │ │ -            ["impl<T: Clone> From<&[T]> for Vec<T>"],
│ │ │ │ │ -            ["impl<T: Clone> From<&mut [T]> for Vec<T>"],
│ │ │ │ │ -            ["impl<T: Clone> From<Cow<'_, [T]>> for Box<[T]>"],
│ │ │ │ │ -            ["impl<T: Clone, const N: usize> From<&[T; N]> for Vec<T>"],
│ │ │ │ │ -            ["impl<T: Clone, const N: usize> From<&mut [T; N]> for Vec<T>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> From<Vec<T, A>> for BinaryHeap<T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, const N: usize> From<[T; N]> for BinaryHeap<T>"],
│ │ │ │ │ -            ["impl<T: Ord, const N: usize> From<[T; N]> for BTreeSet<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A> From<Box<T, A>> for Pin<Box<T, A>>
      where\n    A: 'static + Allocator,
      "],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Arc<T, A>"],
│ │ │ │ │ -            ["impl<W: LocalWake + 'static> From<Rc<W>> for LocalWaker"],
│ │ │ │ │ -            ["impl<W: LocalWake + 'static> From<Rc<W>> for RawWaker"],
│ │ │ │ │ -            ["impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for RawWaker"],
│ │ │ │ │ -            ["impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for Waker"]
│ │ │ │ │ +            ["impl From<&str> for Box<str>"],
│ │ │ │ │ +            ["impl From<&str> for Rc<str>"],
│ │ │ │ │ +            ["impl From<&str> for String"],
│ │ │ │ │ +            ["impl From<&str> for Arc<str>"],
│ │ │ │ │ +            ["impl From<&str> for Vec<u8>"],
│ │ │ │ │ +            ["impl From<&String> for String"],
│ │ │ │ │ +            ["impl From<&CStr> for Box<CStr>"],
│ │ │ │ │ +            ["impl From<&CStr> for CString"],
│ │ │ │ │ +            ["impl From<&CStr> for Rc<CStr>"],
│ │ │ │ │ +            ["impl From<&CStr> for Arc<CStr>"],
│ │ │ │ │ +            ["impl From<&mut str> for String"],
│ │ │ │ │ +            ["impl From<Cow<'_, str>> for Box<str>"],
│ │ │ │ │ +            ["impl From<Cow<'_, CStr>> for Box<CStr>"],
│ │ │ │ │ +            ["impl From<TryReserveErrorKind> for TryReserveError"],
│ │ │ │ │ +            ["impl From<char> for String"],
│ │ │ │ │ +            ["impl From<LayoutError> for TryReserveErrorKind"],
│ │ │ │ │ +            ["impl From<Box<str>> for String"],
│ │ │ │ │ +            ["impl From<Box<CStr>> for CString"],
│ │ │ │ │ +            ["impl From<CString> for Box<CStr>"],
│ │ │ │ │ +            ["impl From<CString> for Rc<CStr>"],
│ │ │ │ │ +            ["impl From<CString> for Arc<CStr>"],
│ │ │ │ │ +            ["impl From<CString> for Vec<u8>"],
│ │ │ │ │ +            ["impl From<Rc<str>> for Rc<[u8]>"],
│ │ │ │ │ +            ["impl From<String> for Box<str>"],
│ │ │ │ │ +            ["impl From<String> for Rc<str>"],
│ │ │ │ │ +            ["impl From<String> for Arc<str>"],
│ │ │ │ │ +            ["impl From<String> for Vec<u8>"],
│ │ │ │ │ +            ["impl From<Arc<str>> for Arc<[u8]>"],
│ │ │ │ │ +            ["impl From<Vec<NonZero<u8>>> for CString"],
│ │ │ │ │ +            ["impl<'a> From<&'a str> for Cow<'a, str>"],
│ │ │ │ │ +            ["impl<'a> From<&'a CString> for Cow<'a, CStr>"],
│ │ │ │ │ +            ["impl<'a> From<&'a String> for Cow<'a, str>"],
│ │ │ │ │ +            ["impl<'a> From<&'a CStr> for Cow<'a, CStr>"],
│ │ │ │ │ +            ["impl<'a> From<&str> for Box<dyn Error + 'a>"],
│ │ │ │ │ +            ["impl<'a> From<&str> for Box<dyn Error + Send + Sync + 'a>"],
│ │ │ │ │ +            ["impl<'a> From<Cow<'a, str>> for String"],
│ │ │ │ │ +            ["impl<'a> From<Cow<'a, CStr>> for CString"],
│ │ │ │ │ +            ["impl<'a> From<CString> for Cow<'a, CStr>"],
│ │ │ │ │ +            ["impl<'a> From<String> for Cow<'a, str>"],
│ │ │ │ │ +            ["impl<'a> From<String> for Box<dyn Error + 'a>"],
│ │ │ │ │ +            ["impl<'a> From<String> for Box<dyn Error + Send + Sync + 'a>"],
│ │ │ │ │ +            ["impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a>"],
│ │ │ │ │ +            ["impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>"],
│ │ │ │ │ +            ["impl<'a, B> From<Cow<'a, B>> for Rc<B>
      where\n    B: ToOwned + ?Sized,\n    Rc<B>: From<&'a B> + From<B::Owned>,
      "],
│ │ │ │ │ +            ["impl<'a, B> From<Cow<'a, B>> for Arc<B>
      where\n    B: ToOwned + ?Sized,\n    Arc<B>: From<&'a B> + From<B::Owned>,
      "],
│ │ │ │ │ +            ["impl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a>"],
│ │ │ │ │ +            ["impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a>"],
│ │ │ │ │ +            ["impl<'a, T> From<Cow<'a, [T]>> for Vec<T>
      where\n    [T]: ToOwned<Owned = Vec<T>>,
      "],
│ │ │ │ │ +            ["impl<'a, T: Clone> From<&'a [T]> for Cow<'a, [T]>"],
│ │ │ │ │ +            ["impl<'a, T: Clone> From<&'a Vec<T>> for Cow<'a, [T]>"],
│ │ │ │ │ +            ["impl<'a, T: Clone> From<Vec<T>> for Cow<'a, [T]>"],
│ │ │ │ │ +            ["impl<'a, T: Clone, const N: usize> From<&'a [T; N]> for Cow<'a, [T]>"],
│ │ │ │ │ +            ["impl<A: Allocator> From<Box<str, A>> for Box<[u8], A>"],
│ │ │ │ │ +            ["impl<K: Ord, V, const N: usize> From<[(K, V); N]> for BTreeMap<K, V>"],
│ │ │ │ │ +            ["impl<T> From<T> for Box<T>"],
│ │ │ │ │ +            ["impl<T> From<T> for Rc<T>"],
│ │ │ │ │ +            ["impl<T> From<T> for Arc<T>"],
│ │ │ │ │ +            ["impl<T, A: Allocator + Clone> From<Vec<T, A>> for Arc<[T], A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> From<BinaryHeap<T, A>> for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> From<Vec<T, A>> for Rc<[T], A>"],
│ │ │ │ │ +            ["impl<T, const N: usize> From<[T; N]> for Box<[T]>"],
│ │ │ │ │ +            ["impl<T, const N: usize> From<[T; N]> for LinkedList<T>"],
│ │ │ │ │ +            ["impl<T, const N: usize> From<[T; N]> for VecDeque<T>"],
│ │ │ │ │ +            ["impl<T, const N: usize> From<[T; N]> for Rc<[T]>"],
│ │ │ │ │ +            ["impl<T, const N: usize> From<[T; N]> for Arc<[T]>"],
│ │ │ │ │ +            ["impl<T, const N: usize> From<[T; N]> for Vec<T>"],
│ │ │ │ │ +            ["impl<T: Clone> From<&[T]> for Box<[T]>"],
│ │ │ │ │ +            ["impl<T: Clone> From<&[T]> for Rc<[T]>"],
│ │ │ │ │ +            ["impl<T: Clone> From<&[T]> for Arc<[T]>"],
│ │ │ │ │ +            ["impl<T: Clone> From<&[T]> for Vec<T>"],
│ │ │ │ │ +            ["impl<T: Clone> From<&mut [T]> for Vec<T>"],
│ │ │ │ │ +            ["impl<T: Clone> From<Cow<'_, [T]>> for Box<[T]>"],
│ │ │ │ │ +            ["impl<T: Clone, const N: usize> From<&[T; N]> for Vec<T>"],
│ │ │ │ │ +            ["impl<T: Clone, const N: usize> From<&mut [T; N]> for Vec<T>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> From<Vec<T, A>> for BinaryHeap<T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, const N: usize> From<[T; N]> for BinaryHeap<T>"],
│ │ │ │ │ +            ["impl<T: Ord, const N: usize> From<[T; N]> for BTreeSet<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A> From<Box<T, A>> for Pin<Box<T, A>>
      where\n    A: 'static + Allocator,
      "],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Arc<T, A>"],
│ │ │ │ │ +            ["impl<W: LocalWake + 'static> From<Rc<W>> for LocalWaker"],
│ │ │ │ │ +            ["impl<W: LocalWake + 'static> From<Rc<W>> for RawWaker"],
│ │ │ │ │ +            ["impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for RawWaker"],
│ │ │ │ │ +            ["impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for Waker"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl From<TokenTree> for TokenStream"],
│ │ │ │ │              ["impl From<Group> for TokenTree"],
│ │ │ │ │              ["impl From<Ident> for TokenTree"],
│ │ │ │ │              ["impl From<Literal> for TokenTree"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/convert/trait.TryFrom.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<T, A: Allocator, const N: usize> TryFrom<Arc<[T], A>> for Arc<[T; N], A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator, const N: usize> TryFrom<Vec<T, A>> for [T; N]"],
│ │ │ │ │ -            ["impl<T, const N: usize> TryFrom<Box<[T]>> for Box<[T; N]>"],
│ │ │ │ │ -            ["impl<T, const N: usize> TryFrom<Rc<[T]>> for Rc<[T; N]>"],
│ │ │ │ │ -            ["impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]>"]
│ │ │ │ │ +            ["impl<T, A: Allocator, const N: usize> TryFrom<Arc<[T], A>> for Arc<[T; N], A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator, const N: usize> TryFrom<Vec<T, A>> for [T; N]"],
│ │ │ │ │ +            ["impl<T, const N: usize> TryFrom<Box<[T]>> for Box<[T; N]>"],
│ │ │ │ │ +            ["impl<T, const N: usize> TryFrom<Rc<[T]>> for Rc<[T; N]>"],
│ │ │ │ │ +            ["impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl TryFrom<HandleOrInvalid> for OwnedHandle"],
│ │ │ │ │              ["impl TryFrom<HandleOrNull> for OwnedHandle"],
│ │ │ │ │              ["impl<'a> TryFrom<&'a OsStr> for &'a str"]
│ │ │ │ │          ]
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/default/trait.Default.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,44 +1,44 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Default for Global"],
│ │ │ │ │ -            ["impl Default for Box<str>"],
│ │ │ │ │ -            ["impl Default for Box<CStr>"],
│ │ │ │ │ -            ["impl Default for CString"],
│ │ │ │ │ -            ["impl Default for String"],
│ │ │ │ │ -            ["impl<'a, K: 'a, V: 'a> Default for Iter<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K: 'a, V: 'a> Default for IterMut<'a, K, V>"],
│ │ │ │ │ -            ["impl<B> Default for Cow<'_, B>
      where\n    B: ToOwned<Owned: Default> + ?Sized,
      "],
│ │ │ │ │ -            ["impl<K, V> Default for BTreeMap<K, V>"],
│ │ │ │ │ -            ["impl<K, V> Default for Keys<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> Default for Range<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> Default for Values<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V, A> Default for IntoIter<K, V, A>
      where\n    A: Allocator + Default + Clone,
      "],
│ │ │ │ │ -            ["impl<K, V, A> Default for IntoKeys<K, V, A>
      where\n    A: Allocator + Default + Clone,
      "],
│ │ │ │ │ -            ["impl<K, V, A> Default for IntoValues<K, V, A>
      where\n    A: Allocator + Default + Clone,
      "],
│ │ │ │ │ -            ["impl<T> Default for Box<[T]>"],
│ │ │ │ │ -            ["impl<T> Default for IntoIter<T>"],
│ │ │ │ │ -            ["impl<T> Default for BTreeSet<T>"],
│ │ │ │ │ -            ["impl<T> Default for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> Default for Range<'_, T>"],
│ │ │ │ │ -            ["impl<T> Default for IntoIter<T>"],
│ │ │ │ │ -            ["impl<T> Default for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> Default for IterMut<'_, T>"],
│ │ │ │ │ -            ["impl<T> Default for LinkedList<T>"],
│ │ │ │ │ -            ["impl<T> Default for VecDeque<T>"],
│ │ │ │ │ -            ["impl<T> Default for Weak<T>"],
│ │ │ │ │ -            ["impl<T> Default for Weak<T>"],
│ │ │ │ │ -            ["impl<T> Default for Vec<T>"],
│ │ │ │ │ -            ["impl<T, A> Default for IntoIter<T, A>
      where\n    A: Allocator + Default + Clone,
      "],
│ │ │ │ │ -            ["impl<T, A> Default for IntoIter<T, A>
      where\n    A: Allocator + Default,
      "],
│ │ │ │ │ -            ["impl<T: Ord> Default for BinaryHeap<T>"],
│ │ │ │ │ -            ["impl<T: Default> Default for Box<T>"],
│ │ │ │ │ -            ["impl<T: Default> Default for Rc<T>"],
│ │ │ │ │ -            ["impl<T: Default> Default for Arc<T>"]
│ │ │ │ │ +            ["impl Default for Global"],
│ │ │ │ │ +            ["impl Default for Box<str>"],
│ │ │ │ │ +            ["impl Default for Box<CStr>"],
│ │ │ │ │ +            ["impl Default for CString"],
│ │ │ │ │ +            ["impl Default for String"],
│ │ │ │ │ +            ["impl<'a, K: 'a, V: 'a> Default for Iter<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K: 'a, V: 'a> Default for IterMut<'a, K, V>"],
│ │ │ │ │ +            ["impl<B> Default for Cow<'_, B>
      where\n    B: ToOwned<Owned: Default> + ?Sized,
      "],
│ │ │ │ │ +            ["impl<K, V> Default for BTreeMap<K, V>"],
│ │ │ │ │ +            ["impl<K, V> Default for Keys<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> Default for Range<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> Default for Values<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V, A> Default for IntoIter<K, V, A>
      where\n    A: Allocator + Default + Clone,
      "],
│ │ │ │ │ +            ["impl<K, V, A> Default for IntoKeys<K, V, A>
      where\n    A: Allocator + Default + Clone,
      "],
│ │ │ │ │ +            ["impl<K, V, A> Default for IntoValues<K, V, A>
      where\n    A: Allocator + Default + Clone,
      "],
│ │ │ │ │ +            ["impl<T> Default for Box<[T]>"],
│ │ │ │ │ +            ["impl<T> Default for IntoIter<T>"],
│ │ │ │ │ +            ["impl<T> Default for BTreeSet<T>"],
│ │ │ │ │ +            ["impl<T> Default for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> Default for Range<'_, T>"],
│ │ │ │ │ +            ["impl<T> Default for IntoIter<T>"],
│ │ │ │ │ +            ["impl<T> Default for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> Default for IterMut<'_, T>"],
│ │ │ │ │ +            ["impl<T> Default for LinkedList<T>"],
│ │ │ │ │ +            ["impl<T> Default for VecDeque<T>"],
│ │ │ │ │ +            ["impl<T> Default for Weak<T>"],
│ │ │ │ │ +            ["impl<T> Default for Weak<T>"],
│ │ │ │ │ +            ["impl<T> Default for Vec<T>"],
│ │ │ │ │ +            ["impl<T, A> Default for IntoIter<T, A>
      where\n    A: Allocator + Default + Clone,
      "],
│ │ │ │ │ +            ["impl<T, A> Default for IntoIter<T, A>
      where\n    A: Allocator + Default,
      "],
│ │ │ │ │ +            ["impl<T: Ord> Default for BinaryHeap<T>"],
│ │ │ │ │ +            ["impl<T: Default> Default for Box<T>"],
│ │ │ │ │ +            ["impl<T: Default> Default for Rc<T>"],
│ │ │ │ │ +            ["impl<T: Default> Default for Arc<T>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl Default for TokenStream"]
│ │ │ │ │          ],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl Default for &OsStr"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/error/trait.Error.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,21 +1,21 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Error for UnorderedKeyError"],
│ │ │ │ │ -            ["impl Error for TryReserveError"],
│ │ │ │ │ -            ["impl Error for FromVecWithNulError"],
│ │ │ │ │ -            ["impl Error for IntoStringError"],
│ │ │ │ │ -            ["impl Error for NulError"],
│ │ │ │ │ -            ["impl Error for FromUtf16Error"],
│ │ │ │ │ -            ["impl Error for FromUtf8Error"],
│ │ │ │ │ -            ["impl<'a, K: Debug + Ord, V: Debug> Error for OccupiedError<'a, K, V>"],
│ │ │ │ │ -            ["impl<T: Error + ?Sized> Error for Arc<T>"],
│ │ │ │ │ -            ["impl<T: Error> Error for Box<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Error> Error for ThinBox<T>"]
│ │ │ │ │ +            ["impl Error for UnorderedKeyError"],
│ │ │ │ │ +            ["impl Error for TryReserveError"],
│ │ │ │ │ +            ["impl Error for FromVecWithNulError"],
│ │ │ │ │ +            ["impl Error for IntoStringError"],
│ │ │ │ │ +            ["impl Error for NulError"],
│ │ │ │ │ +            ["impl Error for FromUtf16Error"],
│ │ │ │ │ +            ["impl Error for FromUtf8Error"],
│ │ │ │ │ +            ["impl<'a, K: Debug + Ord, V: Debug> Error for OccupiedError<'a, K, V>"],
│ │ │ │ │ +            ["impl<T: Error + ?Sized> Error for Arc<T>"],
│ │ │ │ │ +            ["impl<T: Error> Error for Box<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Error> Error for ThinBox<T>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl Error for ExpandError"],
│ │ │ │ │              ["impl Error for LexError"]
│ │ │ │ │          ],
│ │ │ │ │          "std": [
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Debug.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -9,74 +9,74 @@
│ │ │ │ │              ["impl Debug for IntoStringError"],
│ │ │ │ │              ["impl Debug for NulError"],
│ │ │ │ │              ["impl Debug for CString"],
│ │ │ │ │              ["impl Debug for Drain<'_>"],
│ │ │ │ │              ["impl Debug for FromUtf16Error"],
│ │ │ │ │              ["impl Debug for FromUtf8Error"],
│ │ │ │ │              ["impl Debug for String"],
│ │ │ │ │ -            ["impl<'a, I: Debug + Iterator + 'a, A: Debug + Allocator + 'a> Debug for Splice<'a, I, A>
      where\n    I::Item: Debug,
      "],
│ │ │ │ │ +            ["impl<'a, I: Debug + Iterator + 'a, A: Debug + Allocator + 'a> Debug for Splice<'a, I, A>
      where\n    I::Item: Debug,
      "],
│ │ │ │ │              ["impl<'a, T: Debug + 'a> Debug for Range<'a, T>"],
│ │ │ │ │              ["impl<'a, T: Debug + 'a, A: Debug + Allocator> Debug for Drain<'a, T, A>"],
│ │ │ │ │ -            ["impl<'a, T: Debug + Ord, A: Debug + Allocator> Debug for DrainSorted<'a, T, A>"],
│ │ │ │ │ -            ["impl<'a, T: Debug, F, A: Debug + Allocator> Debug for ExtractIf<'a, T, F, A>
      where\n    F: FnMut(&mut T) -> bool + Debug,
      "],
│ │ │ │ │ -            ["impl<B> Debug for Cow<'_, B>
      where\n    B: Debug + ToOwned<Owned: Debug> + ?Sized,
      "],
│ │ │ │ │ -            ["impl<K, V, F> Debug for ExtractIf<'_, K, V, F>
      where\n    K: Debug,\n    V: Debug,\n    F: FnMut(&K, &mut V) -> bool,
      "],
│ │ │ │ │ +            ["impl<'a, T: Debug + Ord, A: Debug + Allocator> Debug for DrainSorted<'a, T, A>"],
│ │ │ │ │ +            ["impl<'a, T: Debug, F, A: Debug + Allocator> Debug for ExtractIf<'a, T, F, A>
      where\n    F: FnMut(&mut T) -> bool + Debug,
      "],
│ │ │ │ │ +            ["impl<B> Debug for Cow<'_, B>
      where\n    B: Debug + ToOwned<Owned: Debug> + ?Sized,
      "],
│ │ │ │ │ +            ["impl<K, V, F> Debug for ExtractIf<'_, K, V, F>
      where\n    K: Debug,\n    V: Debug,\n    F: FnMut(&K, &mut V) -> bool,
      "],
│ │ │ │ │              ["impl<K, V: Debug> Debug for Values<'_, K, V>"],
│ │ │ │ │              ["impl<K, V: Debug> Debug for ValuesMut<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V: Debug, A: Allocator + Clone> Debug for IntoValues<K, V, A>"],
│ │ │ │ │ -            ["impl<K: Debug + Ord, V, A: Allocator + Clone> Debug for VacantEntry<'_, K, V, A>"],
│ │ │ │ │ -            ["impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for Entry<'_, K, V, A>"],
│ │ │ │ │ -            ["impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedEntry<'_, K, V, A>"],
│ │ │ │ │ -            ["impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedError<'_, K, V, A>"],
│ │ │ │ │ +            ["impl<K, V: Debug, A: Allocator + Clone> Debug for IntoValues<K, V, A>"],
│ │ │ │ │ +            ["impl<K: Debug + Ord, V, A: Allocator + Clone> Debug for VacantEntry<'_, K, V, A>"],
│ │ │ │ │ +            ["impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for Entry<'_, K, V, A>"],
│ │ │ │ │ +            ["impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedEntry<'_, K, V, A>"],
│ │ │ │ │ +            ["impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedError<'_, K, V, A>"],
│ │ │ │ │              ["impl<K: Debug, V> Debug for Keys<'_, K, V>"],
│ │ │ │ │ -            ["impl<K: Debug, V, A: Allocator + Clone> Debug for IntoKeys<K, V, A>"],
│ │ │ │ │ +            ["impl<K: Debug, V, A: Allocator + Clone> Debug for IntoKeys<K, V, A>"],
│ │ │ │ │              ["impl<K: Debug, V: Debug> Debug for Cursor<'_, K, V>"],
│ │ │ │ │              ["impl<K: Debug, V: Debug> Debug for Iter<'_, K, V>"],
│ │ │ │ │              ["impl<K: Debug, V: Debug> Debug for IterMut<'_, K, V>"],
│ │ │ │ │              ["impl<K: Debug, V: Debug> Debug for Range<'_, K, V>"],
│ │ │ │ │              ["impl<K: Debug, V: Debug> Debug for RangeMut<'_, K, V>"],
│ │ │ │ │              ["impl<K: Debug, V: Debug, A> Debug for CursorMut<'_, K, V, A>"],
│ │ │ │ │              ["impl<K: Debug, V: Debug, A> Debug for CursorMutKey<'_, K, V, A>"],
│ │ │ │ │ -            ["impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for IntoIter<K, V, A>"],
│ │ │ │ │ -            ["impl<T, F, A: Allocator + Clone> Debug for ExtractIf<'_, T, F, A>
      where\n    T: Debug,\n    F: FnMut(&T) -> bool,
      "],
│ │ │ │ │ -            ["impl<T: Debug + ?Sized, A: Allocator> Debug for Box<T, A>"],
│ │ │ │ │ +            ["impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for IntoIter<K, V, A>"],
│ │ │ │ │ +            ["impl<T, F, A: Allocator + Clone> Debug for ExtractIf<'_, T, F, A>
      where\n    T: Debug,\n    F: FnMut(&T) -> bool,
      "],
│ │ │ │ │ +            ["impl<T: Debug + ?Sized, A: Allocator> Debug for Box<T, A>"],
│ │ │ │ │              ["impl<T: Debug> Debug for Iter<'_, T>"],
│ │ │ │ │              ["impl<T: Debug> Debug for Iter<'_, T>"],
│ │ │ │ │              ["impl<T: Debug> Debug for SymmetricDifference<'_, T>"],
│ │ │ │ │              ["impl<T: Debug> Debug for Union<'_, T>"],
│ │ │ │ │              ["impl<T: Debug> Debug for Iter<'_, T>"],
│ │ │ │ │              ["impl<T: Debug> Debug for IterMut<'_, T>"],
│ │ │ │ │              ["impl<T: Debug> Debug for Iter<'_, T>"],
│ │ │ │ │              ["impl<T: Debug> Debug for IterMut<'_, T>"],
│ │ │ │ │              ["impl<T: Debug> Debug for UniqueRc<T>"],
│ │ │ │ │ -            ["impl<T: Debug, A: Allocator + Clone> Debug for BTreeSet<T, A>"],
│ │ │ │ │ -            ["impl<T: Debug, A: Allocator + Clone> Debug for Difference<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Debug, A: Allocator + Clone> Debug for Intersection<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Debug, A: Allocator + Clone> Debug for BTreeSet<T, A>"],
│ │ │ │ │ +            ["impl<T: Debug, A: Allocator + Clone> Debug for Difference<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Debug, A: Allocator + Clone> Debug for Intersection<'_, T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for BinaryHeap<T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for Cursor<'_, T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for CursorMut<'_, T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for LinkedList<T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for Drain<'_, T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for VecDeque<T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for Drain<'_, T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for IntoIter<T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Allocator> Debug for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: Debug, A: Debug + Allocator + Clone> Debug for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T: Debug, A: Debug + Allocator + Clone> Debug for IntoIter<T, A>"],
│ │ │ │ │              ["impl<T: Debug, A: Debug + Allocator> Debug for IntoIterSorted<T, A>"],
│ │ │ │ │ -            ["impl<T: Debug, F> Debug for ExtractIf<'_, T, F>
      where\n    F: FnMut(&mut T) -> bool,
      "],
│ │ │ │ │ -            ["impl<T: Ord + Debug, A: Allocator> Debug for PeekMut<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Debug> Debug for ThinBox<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Debug, A: Allocator> Debug for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Debug, A: Allocator> Debug for Arc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized> Debug for Weak<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Debug for Weak<T, A>"]
│ │ │ │ │ +            ["impl<T: Debug, F> Debug for ExtractIf<'_, T, F>
      where\n    F: FnMut(&mut T) -> bool,
      "],
│ │ │ │ │ +            ["impl<T: Ord + Debug, A: Allocator> Debug for PeekMut<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Debug> Debug for ThinBox<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Debug, A: Allocator> Debug for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Debug, A: Allocator> Debug for Arc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized> Debug for Weak<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Debug for Weak<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl Debug for Delimiter"],
│ │ │ │ │              ["impl Debug for Level"],
│ │ │ │ │              ["impl Debug for Spacing"],
│ │ │ │ │              ["impl Debug for TokenTree"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Display.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -5,20 +5,20 @@
│ │ │ │ │              ["impl Display for TryReserveError"],
│ │ │ │ │              ["impl Display for FromVecWithNulError"],
│ │ │ │ │              ["impl Display for IntoStringError"],
│ │ │ │ │              ["impl Display for NulError"],
│ │ │ │ │              ["impl Display for FromUtf16Error"],
│ │ │ │ │              ["impl Display for FromUtf8Error"],
│ │ │ │ │              ["impl Display for String"],
│ │ │ │ │ -            ["impl<'a, K: Debug + Ord, V: Debug, A: Allocator + Clone> Display for OccupiedError<'a, K, V, A>"],
│ │ │ │ │ -            ["impl<B> Display for Cow<'_, B>
      where\n    B: Display + ToOwned<Owned: Display> + ?Sized,
      "],
│ │ │ │ │ -            ["impl<T: Display + ?Sized, A: Allocator> Display for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Display> Display for ThinBox<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Display, A: Allocator> Display for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Display, A: Allocator> Display for Arc<T, A>"]
│ │ │ │ │ +            ["impl<'a, K: Debug + Ord, V: Debug, A: Allocator + Clone> Display for OccupiedError<'a, K, V, A>"],
│ │ │ │ │ +            ["impl<B> Display for Cow<'_, B>
      where\n    B: Display + ToOwned<Owned: Display> + ?Sized,
      "],
│ │ │ │ │ +            ["impl<T: Display + ?Sized, A: Allocator> Display for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Display> Display for ThinBox<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Display, A: Allocator> Display for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Display, A: Allocator> Display for Arc<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl Display for TokenTree"],
│ │ │ │ │              ["impl Display for ExpandError"],
│ │ │ │ │              ["impl Display for Group"],
│ │ │ │ │              ["impl Display for Ident"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/fmt/trait.Pointer.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,13 +1,13 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Pointer for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Pointer for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Pointer for Arc<T, A>"]
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Pointer for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Pointer for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Pointer for Arc<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/future/future/trait.Future.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<F: ?Sized + Future + Unpin, A: Allocator> Future for Box<F, A>"]
│ │ │ │ │ +            ["impl<F: ?Sized + Future + Unpin, A: Allocator> Future for Box<F, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/hash/trait.Hash.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,21 +1,21 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Hash for CString"],
│ │ │ │ │ -            ["impl Hash for String"],
│ │ │ │ │ -            ["impl<B> Hash for Cow<'_, B>
      where\n    B: Hash + ToOwned + ?Sized,
      "],
│ │ │ │ │ -            ["impl<K: Hash, V: Hash, A: Allocator + Clone> Hash for BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<T: Hash, A: Allocator + Clone> Hash for BTreeSet<T, A>"],
│ │ │ │ │ -            ["impl<T: Hash, A: Allocator> Hash for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<T: Hash, A: Allocator> Hash for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T: Hash, A: Allocator> Hash for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Hash, A: Allocator> Hash for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Hash, A: Allocator> Hash for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Hash, A: Allocator> Hash for Arc<T, A>"]
│ │ │ │ │ +            ["impl Hash for CString"],
│ │ │ │ │ +            ["impl Hash for String"],
│ │ │ │ │ +            ["impl<B> Hash for Cow<'_, B>
      where\n    B: Hash + ToOwned + ?Sized,
      "],
│ │ │ │ │ +            ["impl<K: Hash, V: Hash, A: Allocator + Clone> Hash for BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<T: Hash, A: Allocator + Clone> Hash for BTreeSet<T, A>"],
│ │ │ │ │ +            ["impl<T: Hash, A: Allocator> Hash for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<T: Hash, A: Allocator> Hash for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T: Hash, A: Allocator> Hash for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Hash, A: Allocator> Hash for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Hash, A: Allocator> Hash for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Hash, A: Allocator> Hash for Arc<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl Hash for ErrorKind"],
│ │ │ │ │              ["impl Hash for OsStr"],
│ │ │ │ │              ["impl Hash for OsString"],
│ │ │ │ │              ["impl Hash for FileType"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/hash/trait.Hasher.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<T: ?Sized + Hasher, A: Allocator> Hasher for Box<T, A>"]
│ │ │ │ │ +            ["impl<T: ?Sized + Hasher, A: Allocator> Hasher for Box<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl Hasher for DefaultHasher"]
│ │ │ │ │          ]
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/collect/trait.Extend.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,28 +1,28 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Extend<char> for String"],
│ │ │ │ │ -            ["impl Extend<Box<str>> for String"],
│ │ │ │ │ -            ["impl Extend<String> for String"],
│ │ │ │ │ -            ["impl<'a> Extend<&'a char> for String"],
│ │ │ │ │ -            ["impl<'a> Extend<&'a str> for String"],
│ │ │ │ │ -            ["impl<'a> Extend<Cow<'a, str>> for String"],
│ │ │ │ │ -            ["impl<'a, K: Ord + Copy, V: Copy, A: Allocator + Clone> Extend<(&'a K, &'a V)> for BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<'a, T: 'a + Ord + Copy, A: Allocator + Clone> Extend<&'a T> for BTreeSet<T, A>"],
│ │ │ │ │ -            ["impl<'a, T: 'a + Ord + Copy, A: Allocator> Extend<&'a T> for BinaryHeap<T, A>"],
│ │ │ │ │ -            ["impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<'a, T: Copy + 'a, A: Allocator> Extend<&'a T> for Vec<T, A>"],
│ │ │ │ │ -            ["impl<K: Ord, V, A: Allocator + Clone> Extend<(K, V)> for BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Extend<T> for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Extend<T> for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Extend<T> for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator + Clone> Extend<T> for BTreeSet<T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> Extend<T> for BinaryHeap<T, A>"]
│ │ │ │ │ +            ["impl Extend<char> for String"],
│ │ │ │ │ +            ["impl Extend<Box<str>> for String"],
│ │ │ │ │ +            ["impl Extend<String> for String"],
│ │ │ │ │ +            ["impl<'a> Extend<&'a char> for String"],
│ │ │ │ │ +            ["impl<'a> Extend<&'a str> for String"],
│ │ │ │ │ +            ["impl<'a> Extend<Cow<'a, str>> for String"],
│ │ │ │ │ +            ["impl<'a, K: Ord + Copy, V: Copy, A: Allocator + Clone> Extend<(&'a K, &'a V)> for BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<'a, T: 'a + Ord + Copy, A: Allocator + Clone> Extend<&'a T> for BTreeSet<T, A>"],
│ │ │ │ │ +            ["impl<'a, T: 'a + Ord + Copy, A: Allocator> Extend<&'a T> for BinaryHeap<T, A>"],
│ │ │ │ │ +            ["impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<'a, T: Copy + 'a, A: Allocator> Extend<&'a T> for Vec<T, A>"],
│ │ │ │ │ +            ["impl<K: Ord, V, A: Allocator + Clone> Extend<(K, V)> for BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Extend<T> for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Extend<T> for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Extend<T> for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator + Clone> Extend<T> for BTreeSet<T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> Extend<T> for BinaryHeap<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl Extend<TokenTree> for TokenStream"],
│ │ │ │ │              ["impl Extend<TokenStream> for TokenStream"]
│ │ │ │ │          ],
│ │ │ │ │          "std": [
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/collect/trait.FromIterator.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,29 +1,29 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl FromIterator<char> for String"],
│ │ │ │ │ -            ["impl FromIterator<Box<str>> for String"],
│ │ │ │ │ -            ["impl FromIterator<String> for String"],
│ │ │ │ │ -            ["impl<'a> FromIterator<&'a char> for String"],
│ │ │ │ │ -            ["impl<'a> FromIterator<&'a str> for String"],
│ │ │ │ │ -            ["impl<'a> FromIterator<Cow<'a, str>> for String"],
│ │ │ │ │ -            ["impl<'a> FromIterator<char> for Cow<'a, str>"],
│ │ │ │ │ -            ["impl<'a> FromIterator<String> for Cow<'a, str>"],
│ │ │ │ │ -            ["impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>"],
│ │ │ │ │ -            ["impl<'a, T> FromIterator<T> for Cow<'a, [T]>
      where\n    T: Clone,
      "],
│ │ │ │ │ -            ["impl<I> FromIterator<I> for Box<[I]>"],
│ │ │ │ │ -            ["impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V>"],
│ │ │ │ │ -            ["impl<T> FromIterator<T> for LinkedList<T>"],
│ │ │ │ │ -            ["impl<T> FromIterator<T> for VecDeque<T>"],
│ │ │ │ │ -            ["impl<T> FromIterator<T> for Rc<[T]>"],
│ │ │ │ │ -            ["impl<T> FromIterator<T> for Arc<[T]>"],
│ │ │ │ │ -            ["impl<T> FromIterator<T> for Vec<T>"],
│ │ │ │ │ -            ["impl<T: Ord> FromIterator<T> for BinaryHeap<T>"],
│ │ │ │ │ -            ["impl<T: Ord> FromIterator<T> for BTreeSet<T>"]
│ │ │ │ │ +            ["impl FromIterator<char> for String"],
│ │ │ │ │ +            ["impl FromIterator<Box<str>> for String"],
│ │ │ │ │ +            ["impl FromIterator<String> for String"],
│ │ │ │ │ +            ["impl<'a> FromIterator<&'a char> for String"],
│ │ │ │ │ +            ["impl<'a> FromIterator<&'a str> for String"],
│ │ │ │ │ +            ["impl<'a> FromIterator<Cow<'a, str>> for String"],
│ │ │ │ │ +            ["impl<'a> FromIterator<char> for Cow<'a, str>"],
│ │ │ │ │ +            ["impl<'a> FromIterator<String> for Cow<'a, str>"],
│ │ │ │ │ +            ["impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>"],
│ │ │ │ │ +            ["impl<'a, T> FromIterator<T> for Cow<'a, [T]>
      where\n    T: Clone,
      "],
│ │ │ │ │ +            ["impl<I> FromIterator<I> for Box<[I]>"],
│ │ │ │ │ +            ["impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V>"],
│ │ │ │ │ +            ["impl<T> FromIterator<T> for LinkedList<T>"],
│ │ │ │ │ +            ["impl<T> FromIterator<T> for VecDeque<T>"],
│ │ │ │ │ +            ["impl<T> FromIterator<T> for Rc<[T]>"],
│ │ │ │ │ +            ["impl<T> FromIterator<T> for Arc<[T]>"],
│ │ │ │ │ +            ["impl<T> FromIterator<T> for Vec<T>"],
│ │ │ │ │ +            ["impl<T: Ord> FromIterator<T> for BinaryHeap<T>"],
│ │ │ │ │ +            ["impl<T: Ord> FromIterator<T> for BTreeSet<T>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl FromIterator<TokenTree> for TokenStream"],
│ │ │ │ │              ["impl FromIterator<TokenStream> for TokenStream"]
│ │ │ │ │          ],
│ │ │ │ │          "std": [
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/collect/trait.IntoIterator.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,26 +1,26 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<'a, K, V, A: Allocator + Clone> IntoIterator for &'a BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<'a, K, V, A: Allocator + Clone> IntoIterator for &'a mut BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<'a, T, A: Allocator + Clone> IntoIterator for &'a BTreeSet<T, A>"],
│ │ │ │ │ -            ["impl<'a, T, A: Allocator> IntoIterator for &'a BinaryHeap<T, A>"],
│ │ │ │ │ -            ["impl<'a, T, A: Allocator> IntoIterator for &'a LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<'a, T, A: Allocator> IntoIterator for &'a Vec<T, A>"],
│ │ │ │ │ -            ["impl<'a, T, A: Allocator> IntoIterator for &'a mut LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec<T, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> IntoIterator for BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator + Clone> IntoIterator for BTreeSet<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> IntoIterator for BinaryHeap<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> IntoIterator for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> IntoIterator for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> IntoIterator for Vec<T, A>"]
│ │ │ │ │ +            ["impl<'a, K, V, A: Allocator + Clone> IntoIterator for &'a BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<'a, K, V, A: Allocator + Clone> IntoIterator for &'a mut BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<'a, T, A: Allocator + Clone> IntoIterator for &'a BTreeSet<T, A>"],
│ │ │ │ │ +            ["impl<'a, T, A: Allocator> IntoIterator for &'a BinaryHeap<T, A>"],
│ │ │ │ │ +            ["impl<'a, T, A: Allocator> IntoIterator for &'a LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<'a, T, A: Allocator> IntoIterator for &'a Vec<T, A>"],
│ │ │ │ │ +            ["impl<'a, T, A: Allocator> IntoIterator for &'a mut LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec<T, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> IntoIterator for BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator + Clone> IntoIterator for BTreeSet<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> IntoIterator for BinaryHeap<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> IntoIterator for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> IntoIterator for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> IntoIterator for Vec<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl IntoIterator for TokenStream"]
│ │ │ │ │          ],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl<'a> IntoIterator for &'a UnixListener"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/double_ended/trait.DoubleEndedIterator.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,38 +1,38 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl DoubleEndedIterator for Drain<'_>"],
│ │ │ │ │ -            ["impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K, V> DoubleEndedIterator for Range<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K: 'a, V: 'a> DoubleEndedIterator for Iter<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, T> DoubleEndedIterator for Iter<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> DoubleEndedIterator for Iter<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> DoubleEndedIterator for Range<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> DoubleEndedIterator for Iter<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> DoubleEndedIterator for IterMut<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> DoubleEndedIterator for Iter<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> DoubleEndedIterator for IterMut<'a, T>"],
│ │ │ │ │ -            ["impl<I: DoubleEndedIterator + ?Sized, A: Allocator> DoubleEndedIterator for Box<I, A>"],
│ │ │ │ │ -            ["impl<I: Iterator, A: Allocator> DoubleEndedIterator for Splice<'_, I, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoIter<K, V, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoKeys<K, V, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoValues<K, V, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator + Clone> DoubleEndedIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>"]
│ │ │ │ │ +            ["impl DoubleEndedIterator for Drain<'_>"],
│ │ │ │ │ +            ["impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K, V> DoubleEndedIterator for Range<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K: 'a, V: 'a> DoubleEndedIterator for Iter<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, T> DoubleEndedIterator for Iter<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> DoubleEndedIterator for Iter<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> DoubleEndedIterator for Range<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> DoubleEndedIterator for Iter<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> DoubleEndedIterator for IterMut<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> DoubleEndedIterator for Iter<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> DoubleEndedIterator for IterMut<'a, T>"],
│ │ │ │ │ +            ["impl<I: DoubleEndedIterator + ?Sized, A: Allocator> DoubleEndedIterator for Box<I, A>"],
│ │ │ │ │ +            ["impl<I: Iterator, A: Allocator> DoubleEndedIterator for Splice<'_, I, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoIter<K, V, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoKeys<K, V, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> DoubleEndedIterator for IntoValues<K, V, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator + Clone> DoubleEndedIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl DoubleEndedIterator for Args"],
│ │ │ │ │              ["impl DoubleEndedIterator for ArgsOs"],
│ │ │ │ │              ["impl<'a> DoubleEndedIterator for Components<'a>"],
│ │ │ │ │              ["impl<'a> DoubleEndedIterator for Iter<'a>"]
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/exact_size/trait.ExactSizeIterator.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,36 +1,36 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<I: ExactSizeIterator + ?Sized, A: Allocator> ExactSizeIterator for Box<I, A>"],
│ │ │ │ │ -            ["impl<I: Iterator, A: Allocator> ExactSizeIterator for Splice<'_, I, A>"],
│ │ │ │ │ -            ["impl<K, V> ExactSizeIterator for Iter<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> ExactSizeIterator for IterMut<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> ExactSizeIterator for Keys<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> ExactSizeIterator for Values<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoIter<K, V, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoKeys<K, V, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoValues<K, V, A>"],
│ │ │ │ │ -            ["impl<T> ExactSizeIterator for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> ExactSizeIterator for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> ExactSizeIterator for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> ExactSizeIterator for IterMut<'_, T>"],
│ │ │ │ │ -            ["impl<T> ExactSizeIterator for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> ExactSizeIterator for IterMut<'_, T>"],
│ │ │ │ │ -            ["impl<T, A: Allocator + Clone> ExactSizeIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> ExactSizeIterator for DrainSorted<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> ExactSizeIterator for IntoIterSorted<T, A>"]
│ │ │ │ │ +            ["impl<I: ExactSizeIterator + ?Sized, A: Allocator> ExactSizeIterator for Box<I, A>"],
│ │ │ │ │ +            ["impl<I: Iterator, A: Allocator> ExactSizeIterator for Splice<'_, I, A>"],
│ │ │ │ │ +            ["impl<K, V> ExactSizeIterator for Iter<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> ExactSizeIterator for IterMut<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> ExactSizeIterator for Keys<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> ExactSizeIterator for Values<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoIter<K, V, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoKeys<K, V, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoValues<K, V, A>"],
│ │ │ │ │ +            ["impl<T> ExactSizeIterator for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> ExactSizeIterator for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> ExactSizeIterator for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> ExactSizeIterator for IterMut<'_, T>"],
│ │ │ │ │ +            ["impl<T> ExactSizeIterator for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> ExactSizeIterator for IterMut<'_, T>"],
│ │ │ │ │ +            ["impl<T, A: Allocator + Clone> ExactSizeIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> ExactSizeIterator for DrainSorted<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> ExactSizeIterator for IntoIterSorted<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl ExactSizeIterator for Args"],
│ │ │ │ │              ["impl ExactSizeIterator for ArgsOs"],
│ │ │ │ │              ["impl<'a> ExactSizeIterator for CommandArgs<'a>"],
│ │ │ │ │              ["impl<'a> ExactSizeIterator for CommandEnvs<'a>"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/iterator/trait.Iterator.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,48 +1,48 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Iterator for Drain<'_>"],
│ │ │ │ │ -            ["impl<'a, K, V> Iterator for IterMut<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K, V> Iterator for Keys<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K, V> Iterator for Range<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K, V> Iterator for RangeMut<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K, V> Iterator for Values<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K, V> Iterator for ValuesMut<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V>"],
│ │ │ │ │ -            ["impl<'a, T> Iterator for Iter<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> Iterator for Iter<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> Iterator for Range<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> Iterator for Iter<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> Iterator for IterMut<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> Iterator for Iter<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T> Iterator for IterMut<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T, F, A: Allocator + Clone> Iterator for ExtractIf<'_, T, F, A>
      where\n    F: 'a + FnMut(&T) -> bool,
      "],
│ │ │ │ │ -            ["impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T: Ord> Iterator for Union<'a, T>"],
│ │ │ │ │ -            ["impl<'a, T: Ord, A: Allocator + Clone> Iterator for Difference<'a, T, A>"],
│ │ │ │ │ -            ["impl<'a, T: Ord, A: Allocator + Clone> Iterator for Intersection<'a, T, A>"],
│ │ │ │ │ -            ["impl<I: Iterator + ?Sized, A: Allocator> Iterator for Box<I, A>"],
│ │ │ │ │ -            ["impl<I: Iterator, A: Allocator> Iterator for Splice<'_, I, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> Iterator for IntoIter<K, V, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> Iterator for IntoKeys<K, V, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> Iterator for IntoValues<K, V, A>"],
│ │ │ │ │ -            ["impl<K, V, F, A: Allocator + Clone> Iterator for ExtractIf<'_, K, V, F, A>
      where\n    F: FnMut(&K, &mut V) -> bool,
      "],
│ │ │ │ │ -            ["impl<T, A: Allocator + Clone> Iterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Iterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Iterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Iterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Iterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Iterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Iterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Iterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
      where\n    F: FnMut(&mut T) -> bool,
      "],
│ │ │ │ │ -            ["impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
      where\n    F: FnMut(&mut T) -> bool,
      "],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> Iterator for DrainSorted<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> Iterator for IntoIterSorted<T, A>"]
│ │ │ │ │ +            ["impl Iterator for Drain<'_>"],
│ │ │ │ │ +            ["impl<'a, K, V> Iterator for IterMut<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K, V> Iterator for Keys<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K, V> Iterator for Range<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K, V> Iterator for RangeMut<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K, V> Iterator for Values<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K, V> Iterator for ValuesMut<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V>"],
│ │ │ │ │ +            ["impl<'a, T> Iterator for Iter<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> Iterator for Iter<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> Iterator for Range<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> Iterator for Iter<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> Iterator for IterMut<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> Iterator for Iter<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T> Iterator for IterMut<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T, F, A: Allocator + Clone> Iterator for ExtractIf<'_, T, F, A>
      where\n    F: 'a + FnMut(&T) -> bool,
      "],
│ │ │ │ │ +            ["impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T: Ord> Iterator for Union<'a, T>"],
│ │ │ │ │ +            ["impl<'a, T: Ord, A: Allocator + Clone> Iterator for Difference<'a, T, A>"],
│ │ │ │ │ +            ["impl<'a, T: Ord, A: Allocator + Clone> Iterator for Intersection<'a, T, A>"],
│ │ │ │ │ +            ["impl<I: Iterator + ?Sized, A: Allocator> Iterator for Box<I, A>"],
│ │ │ │ │ +            ["impl<I: Iterator, A: Allocator> Iterator for Splice<'_, I, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> Iterator for IntoIter<K, V, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> Iterator for IntoKeys<K, V, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> Iterator for IntoValues<K, V, A>"],
│ │ │ │ │ +            ["impl<K, V, F, A: Allocator + Clone> Iterator for ExtractIf<'_, K, V, F, A>
      where\n    F: FnMut(&K, &mut V) -> bool,
      "],
│ │ │ │ │ +            ["impl<T, A: Allocator + Clone> Iterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Iterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Iterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Iterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Iterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Iterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Iterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Iterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
      where\n    F: FnMut(&mut T) -> bool,
      "],
│ │ │ │ │ +            ["impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
      where\n    F: FnMut(&mut T) -> bool,
      "],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> Iterator for DrainSorted<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> Iterator for IntoIterSorted<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl Iterator for IntoIter"]
│ │ │ │ │          ],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl Iterator for Args"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/marker/trait.FusedIterator.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,45 +1,45 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl FusedIterator for Drain<'_>"],
│ │ │ │ │ -            ["impl<I: FusedIterator + ?Sized, A: Allocator> FusedIterator for Box<I, A>"],
│ │ │ │ │ -            ["impl<K, V> FusedIterator for Iter<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> FusedIterator for IterMut<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> FusedIterator for Keys<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> FusedIterator for Range<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> FusedIterator for RangeMut<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> FusedIterator for Values<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V> FusedIterator for ValuesMut<'_, K, V>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> FusedIterator for IntoIter<K, V, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> FusedIterator for IntoKeys<K, V, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> FusedIterator for IntoValues<K, V, A>"],
│ │ │ │ │ -            ["impl<K, V, F> FusedIterator for ExtractIf<'_, K, V, F>
      where\n    F: FnMut(&K, &mut V) -> bool,
      "],
│ │ │ │ │ -            ["impl<T> FusedIterator for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> FusedIterator for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> FusedIterator for Range<'_, T>"],
│ │ │ │ │ -            ["impl<T> FusedIterator for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> FusedIterator for IterMut<'_, T>"],
│ │ │ │ │ -            ["impl<T> FusedIterator for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> FusedIterator for IterMut<'_, T>"],
│ │ │ │ │ -            ["impl<T, A: Allocator + Clone> FusedIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> FusedIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> FusedIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> FusedIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> FusedIterator for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, F, A: Allocator + Clone> FusedIterator for ExtractIf<'_, T, F, A>
      where\n    F: FnMut(&T) -> bool,
      "],
│ │ │ │ │ -            ["impl<T: Ord> FusedIterator for SymmetricDifference<'_, T>"],
│ │ │ │ │ -            ["impl<T: Ord> FusedIterator for Union<'_, T>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator + Clone> FusedIterator for Difference<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator + Clone> FusedIterator for Intersection<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> FusedIterator for DrainSorted<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> FusedIterator for IntoIterSorted<T, A>"]
│ │ │ │ │ +            ["impl FusedIterator for Drain<'_>"],
│ │ │ │ │ +            ["impl<I: FusedIterator + ?Sized, A: Allocator> FusedIterator for Box<I, A>"],
│ │ │ │ │ +            ["impl<K, V> FusedIterator for Iter<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> FusedIterator for IterMut<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> FusedIterator for Keys<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> FusedIterator for Range<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> FusedIterator for RangeMut<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> FusedIterator for Values<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V> FusedIterator for ValuesMut<'_, K, V>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> FusedIterator for IntoIter<K, V, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> FusedIterator for IntoKeys<K, V, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> FusedIterator for IntoValues<K, V, A>"],
│ │ │ │ │ +            ["impl<K, V, F> FusedIterator for ExtractIf<'_, K, V, F>
      where\n    F: FnMut(&K, &mut V) -> bool,
      "],
│ │ │ │ │ +            ["impl<T> FusedIterator for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> FusedIterator for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> FusedIterator for Range<'_, T>"],
│ │ │ │ │ +            ["impl<T> FusedIterator for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> FusedIterator for IterMut<'_, T>"],
│ │ │ │ │ +            ["impl<T> FusedIterator for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> FusedIterator for IterMut<'_, T>"],
│ │ │ │ │ +            ["impl<T, A: Allocator + Clone> FusedIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> FusedIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> FusedIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> FusedIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> FusedIterator for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> FusedIterator for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, F, A: Allocator + Clone> FusedIterator for ExtractIf<'_, T, F, A>
      where\n    F: FnMut(&T) -> bool,
      "],
│ │ │ │ │ +            ["impl<T: Ord> FusedIterator for SymmetricDifference<'_, T>"],
│ │ │ │ │ +            ["impl<T: Ord> FusedIterator for Union<'_, T>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator + Clone> FusedIterator for Difference<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator + Clone> FusedIterator for Intersection<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> FusedIterator for DrainSorted<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> FusedIterator for IntoIterSorted<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl FusedIterator for Incoming<'_>"],
│ │ │ │ │              ["impl FusedIterator for IntoIncoming"],
│ │ │ │ │              ["impl FusedIterator for EncodeWide<'_>"],
│ │ │ │ │              ["impl FusedIterator for Ancestors<'_>"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/iter/traits/marker/trait.TrustedLen.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,17 +1,17 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<T> TrustedLen for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T> TrustedLen for IterMut<'_, T>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> TrustedLen for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> TrustedLen for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> TrustedLen for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> TrustedLen for DrainSorted<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> TrustedLen for IntoIterSorted<T, A>"]
│ │ │ │ │ +            ["impl<T> TrustedLen for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T> TrustedLen for IterMut<'_, T>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> TrustedLen for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> TrustedLen for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> TrustedLen for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> TrustedLen for DrainSorted<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> TrustedLen for IntoIterSorted<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Copy.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Copy for Global"]
│ │ │ │ │ +            ["impl Copy for Global"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl Copy for Delimiter"],
│ │ │ │ │              ["impl Copy for Level"],
│ │ │ │ │              ["impl Copy for Spacing"],
│ │ │ │ │              ["impl Copy for Span"]
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Freeze.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,82 +1,82 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Freeze for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ -            ["impl Freeze for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ -            ["impl Freeze for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ -            ["impl Freeze for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ -            ["impl Freeze for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ -            ["impl Freeze for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ -            ["impl Freeze for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ -            ["impl Freeze for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ -            ["impl Freeze for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ -            ["impl Freeze for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ -            ["impl Freeze for String", 1, ["alloc::string::String"]],
│ │ │ │ │ -            ["impl<'a> Freeze for Drain<'a>", 1, ["alloc::string::Drain"]],
│ │ │ │ │ -            ["impl<'a, B: ?Sized> Freeze for Cow<'a, B>
      where\n    <B as ToOwned>::Owned: Freeze,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ -            ["impl<'a, I, A> Freeze for Splice<'a, I, A>
      where\n    I: Freeze,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ -            ["impl<'a, K, V> Freeze for Cursor<'a, K, V>", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ -            ["impl<'a, K, V> Freeze for Iter<'a, K, V>", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ -            ["impl<'a, K, V> Freeze for IterMut<'a, K, V>", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> Freeze for Keys<'a, K, V>", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ -            ["impl<'a, K, V> Freeze for Range<'a, K, V>", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ -            ["impl<'a, K, V> Freeze for RangeMut<'a, K, V>", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> Freeze for Values<'a, K, V>", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ -            ["impl<'a, K, V> Freeze for ValuesMut<'a, K, V>", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Freeze for Entry<'a, K, V, A>
      where\n    A: Freeze,\n    K: Freeze,
      ", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Freeze for CursorMut<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Freeze for CursorMutKey<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Freeze for OccupiedEntry<'a, K, V, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Freeze for OccupiedError<'a, K, V, A>
      where\n    A: Freeze,\n    V: Freeze,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Freeze for VacantEntry<'a, K, V, A>
      where\n    A: Freeze,\n    K: Freeze,
      ", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, F, A> Freeze for ExtractIf<'a, K, V, F, A>
      where\n    A: Freeze,\n    F: Freeze,
      ", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T> Freeze for Iter<'a, T>", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Freeze for Iter<'a, T>", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Freeze for Range<'a, T>", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ -            ["impl<'a, T> Freeze for SymmetricDifference<'a, T>", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ -            ["impl<'a, T> Freeze for Union<'a, T>", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ -            ["impl<'a, T> Freeze for Iter<'a, T>", 1, ["alloc::collections::linked_list::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Freeze for IterMut<'a, T>", 1, ["alloc::collections::linked_list::IterMut"]],
│ │ │ │ │ -            ["impl<'a, T> Freeze for Iter<'a, T>", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Freeze for IterMut<'a, T>", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> Freeze for Drain<'a, T, A>", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, A> Freeze for DrainSorted<'a, T, A>", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ -            ["impl<'a, T, A> Freeze for PeekMut<'a, T, A>", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> Freeze for Difference<'a, T, A>", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ -            ["impl<'a, T, A> Freeze for Intersection<'a, T, A>", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ -            ["impl<'a, T, A> Freeze for Cursor<'a, T, A>", 1, ["alloc::collections::linked_list::Cursor"]],
│ │ │ │ │ -            ["impl<'a, T, A> Freeze for CursorMut<'a, T, A>", 1, ["alloc::collections::linked_list::CursorMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> Freeze for Drain<'a, T, A>", 1, ["alloc::collections::vec_deque::drain::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, A> Freeze for Drain<'a, T, A>", 1, ["alloc::vec::drain::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
      where\n    A: Freeze,\n    F: Freeze,
      ", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
      where\n    F: Freeze,
      ", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
      where\n    F: Freeze,
      ", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ -            ["impl<K, V, A> Freeze for BTreeMap<K, V, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::map::BTreeMap"]],
│ │ │ │ │ -            ["impl<K, V, A> Freeze for IntoIter<K, V, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ -            ["impl<K, V, A> Freeze for IntoKeys<K, V, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ -            ["impl<K, V, A> Freeze for IntoValues<K, V, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ -            ["impl<T> Freeze for UniqueRc<T>", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ -            ["impl<T, A> Freeze for BinaryHeap<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ -            ["impl<T, A> Freeze for IntoIter<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Freeze for IntoIterSorted<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ -            ["impl<T, A> Freeze for BTreeSet<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ -            ["impl<T, A> Freeze for IntoIter<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Freeze for IntoIter<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Freeze for LinkedList<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::linked_list::LinkedList"]],
│ │ │ │ │ -            ["impl<T, A> Freeze for IntoIter<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Freeze for VecDeque<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ -            ["impl<T, A> Freeze for IntoIter<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::vec::into_iter::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Freeze for Vec<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ -            ["impl<T: ?Sized> Freeze for ThinBox<T>", 1, ["alloc::boxed::thin::ThinBox"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> Freeze for Box<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::boxed::Box"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> Freeze for Rc<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::rc::Rc"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> Freeze for Weak<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::rc::Weak"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> Freeze for Arc<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::sync::Arc"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> Freeze for Weak<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::sync::Weak"]]
│ │ │ │ │ +            ["impl Freeze for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ +            ["impl Freeze for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ +            ["impl Freeze for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ +            ["impl Freeze for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ +            ["impl Freeze for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ +            ["impl Freeze for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ +            ["impl Freeze for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ +            ["impl Freeze for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ +            ["impl Freeze for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ +            ["impl Freeze for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ +            ["impl Freeze for String", 1, ["alloc::string::String"]],
│ │ │ │ │ +            ["impl<'a> Freeze for Drain<'a>", 1, ["alloc::string::Drain"]],
│ │ │ │ │ +            ["impl<'a, B: ?Sized> Freeze for Cow<'a, B>
      where\n    <B as ToOwned>::Owned: Freeze,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ +            ["impl<'a, I, A> Freeze for Splice<'a, I, A>
      where\n    I: Freeze,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ +            ["impl<'a, K, V> Freeze for Cursor<'a, K, V>", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ +            ["impl<'a, K, V> Freeze for Iter<'a, K, V>", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ +            ["impl<'a, K, V> Freeze for IterMut<'a, K, V>", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> Freeze for Keys<'a, K, V>", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ +            ["impl<'a, K, V> Freeze for Range<'a, K, V>", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ +            ["impl<'a, K, V> Freeze for RangeMut<'a, K, V>", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> Freeze for Values<'a, K, V>", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ +            ["impl<'a, K, V> Freeze for ValuesMut<'a, K, V>", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Freeze for Entry<'a, K, V, A>
      where\n    A: Freeze,\n    K: Freeze,
      ", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Freeze for CursorMut<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Freeze for CursorMutKey<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Freeze for OccupiedEntry<'a, K, V, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Freeze for OccupiedError<'a, K, V, A>
      where\n    A: Freeze,\n    V: Freeze,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Freeze for VacantEntry<'a, K, V, A>
      where\n    A: Freeze,\n    K: Freeze,
      ", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, F, A> Freeze for ExtractIf<'a, K, V, F, A>
      where\n    A: Freeze,\n    F: Freeze,
      ", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T> Freeze for Iter<'a, T>", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Freeze for Iter<'a, T>", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Freeze for Range<'a, T>", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ +            ["impl<'a, T> Freeze for SymmetricDifference<'a, T>", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ +            ["impl<'a, T> Freeze for Union<'a, T>", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ +            ["impl<'a, T> Freeze for Iter<'a, T>", 1, ["alloc::collections::linked_list::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Freeze for IterMut<'a, T>", 1, ["alloc::collections::linked_list::IterMut"]],
│ │ │ │ │ +            ["impl<'a, T> Freeze for Iter<'a, T>", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Freeze for IterMut<'a, T>", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> Freeze for Drain<'a, T, A>", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, A> Freeze for DrainSorted<'a, T, A>", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ +            ["impl<'a, T, A> Freeze for PeekMut<'a, T, A>", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> Freeze for Difference<'a, T, A>", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ +            ["impl<'a, T, A> Freeze for Intersection<'a, T, A>", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ +            ["impl<'a, T, A> Freeze for Cursor<'a, T, A>", 1, ["alloc::collections::linked_list::Cursor"]],
│ │ │ │ │ +            ["impl<'a, T, A> Freeze for CursorMut<'a, T, A>", 1, ["alloc::collections::linked_list::CursorMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> Freeze for Drain<'a, T, A>", 1, ["alloc::collections::vec_deque::drain::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, A> Freeze for Drain<'a, T, A>", 1, ["alloc::vec::drain::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
      where\n    A: Freeze,\n    F: Freeze,
      ", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
      where\n    F: Freeze,
      ", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> Freeze for ExtractIf<'a, T, F, A>
      where\n    F: Freeze,
      ", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ +            ["impl<K, V, A> Freeze for BTreeMap<K, V, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::map::BTreeMap"]],
│ │ │ │ │ +            ["impl<K, V, A> Freeze for IntoIter<K, V, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ +            ["impl<K, V, A> Freeze for IntoKeys<K, V, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ +            ["impl<K, V, A> Freeze for IntoValues<K, V, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ +            ["impl<T> Freeze for UniqueRc<T>", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ +            ["impl<T, A> Freeze for BinaryHeap<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ +            ["impl<T, A> Freeze for IntoIter<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Freeze for IntoIterSorted<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ +            ["impl<T, A> Freeze for BTreeSet<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ +            ["impl<T, A> Freeze for IntoIter<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Freeze for IntoIter<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Freeze for LinkedList<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::linked_list::LinkedList"]],
│ │ │ │ │ +            ["impl<T, A> Freeze for IntoIter<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Freeze for VecDeque<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ +            ["impl<T, A> Freeze for IntoIter<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::vec::into_iter::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Freeze for Vec<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ +            ["impl<T: ?Sized> Freeze for ThinBox<T>", 1, ["alloc::boxed::thin::ThinBox"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> Freeze for Box<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::boxed::Box"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> Freeze for Rc<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::rc::Rc"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> Freeze for Weak<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::rc::Weak"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> Freeze for Arc<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::sync::Arc"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> Freeze for Weak<T, A>
      where\n    A: Freeze,
      ", 1, ["alloc::sync::Weak"]]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl Freeze for Delimiter", 1, ["proc_macro::Delimiter"]],
│ │ │ │ │              ["impl Freeze for Level", 1, ["proc_macro::diagnostic::Level"]],
│ │ │ │ │              ["impl Freeze for Spacing", 1, ["proc_macro::Spacing"]],
│ │ │ │ │              ["impl Freeze for TokenTree", 1, ["proc_macro::TokenTree"]],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Send.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,82 +1,82 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Send for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ -            ["impl Send for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ -            ["impl Send for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ -            ["impl Send for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ -            ["impl Send for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ -            ["impl Send for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ -            ["impl Send for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ -            ["impl Send for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ -            ["impl Send for Drain<'_>"],
│ │ │ │ │ -            ["impl Send for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ -            ["impl Send for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ -            ["impl Send for String", 1, ["alloc::string::String"]],
│ │ │ │ │ -            ["impl<'a, B: ?Sized> Send for Cow<'a, B>
      where\n    B: Sync,\n    <B as ToOwned>::Owned: Send,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ -            ["impl<'a, I, A> Send for Splice<'a, I, A>
      where\n    A: Send,\n    I: Send,\n    <I as Iterator>::Item: Send,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ -            ["impl<'a, K, V> Send for Cursor<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ -            ["impl<'a, K, V> Send for Iter<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ -            ["impl<'a, K, V> Send for IterMut<'a, K, V>
      where\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> Send for Keys<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ -            ["impl<'a, K, V> Send for Range<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ -            ["impl<'a, K, V> Send for RangeMut<'a, K, V>
      where\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> Send for Values<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ -            ["impl<'a, K, V> Send for ValuesMut<'a, K, V>
      where\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Send for Entry<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Send for CursorMut<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Send for CursorMutKey<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Send for OccupiedEntry<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Send for OccupiedError<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Send for VacantEntry<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, F, A> Send for ExtractIf<'a, K, V, F, A>
      where\n    A: Send,\n    F: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T> Send for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Send for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Send for Range<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ -            ["impl<'a, T> Send for SymmetricDifference<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ -            ["impl<'a, T> Send for Union<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ -            ["impl<'a, T> Send for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Send for IterMut<'a, T>
      where\n    T: Send,
      ", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> Send for Drain<'a, T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, A> Send for DrainSorted<'a, T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ -            ["impl<'a, T, A> Send for PeekMut<'a, T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> Send for Difference<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ -            ["impl<'a, T, A> Send for Intersection<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ -            ["impl<'a, T, F, A = Global> !Send for ExtractIf<'a, T, F, A>", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> Send for ExtractIf<'a, T, F, A>
      where\n    A: Send,\n    F: Send,\n    T: Send,
      ", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> Send for ExtractIf<'a, T, F, A>
      where\n    A: Send,\n    F: Send,\n    T: Send,
      ", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ -            ["impl<K, V, A> Send for BTreeMap<K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::BTreeMap"]],
│ │ │ │ │ -            ["impl<K, V, A> Send for IntoIter<K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ -            ["impl<K, V, A> Send for IntoKeys<K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ -            ["impl<K, V, A> Send for IntoValues<K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ -            ["impl<T> !Send for UniqueRc<T>", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ -            ["impl<T, A> Send for BinaryHeap<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ -            ["impl<T, A> Send for IntoIter<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Send for IntoIterSorted<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ -            ["impl<T, A> Send for BTreeSet<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ -            ["impl<T, A> Send for IntoIter<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Send for IntoIter<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Send for IntoIter<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Send for VecDeque<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ -            ["impl<T, A> Send for Vec<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ -            ["impl<T: Send> Send for IterMut<'_, T>"],
│ │ │ │ │ -            ["impl<T: Send, A: Allocator + Send> Send for CursorMut<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Send, A: Allocator + Send> Send for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<T: Send, A: Allocator + Send> Send for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Send, A: Allocator + Send> Send for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T: Send, A: Send + Allocator> Send for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Sync> Send for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T: Sync, A: Allocator + Sync> Send for Cursor<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Send> Send for ThinBox<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Sync + Send, A: Allocator + Send> Send for Arc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Sync + Send, A: Allocator + Send> Send for Weak<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A> Send for Box<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::boxed::Box"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> !Send for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> !Send for Weak<T, A>"]
│ │ │ │ │ +            ["impl Send for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ +            ["impl Send for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ +            ["impl Send for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ +            ["impl Send for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ +            ["impl Send for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ +            ["impl Send for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ +            ["impl Send for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ +            ["impl Send for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ +            ["impl Send for Drain<'_>"],
│ │ │ │ │ +            ["impl Send for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ +            ["impl Send for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ +            ["impl Send for String", 1, ["alloc::string::String"]],
│ │ │ │ │ +            ["impl<'a, B: ?Sized> Send for Cow<'a, B>
      where\n    B: Sync,\n    <B as ToOwned>::Owned: Send,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ +            ["impl<'a, I, A> Send for Splice<'a, I, A>
      where\n    A: Send,\n    I: Send,\n    <I as Iterator>::Item: Send,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ +            ["impl<'a, K, V> Send for Cursor<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ +            ["impl<'a, K, V> Send for Iter<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ +            ["impl<'a, K, V> Send for IterMut<'a, K, V>
      where\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> Send for Keys<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ +            ["impl<'a, K, V> Send for Range<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ +            ["impl<'a, K, V> Send for RangeMut<'a, K, V>
      where\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> Send for Values<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ +            ["impl<'a, K, V> Send for ValuesMut<'a, K, V>
      where\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Send for Entry<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Send for CursorMut<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Send for CursorMutKey<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Send for OccupiedEntry<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Send for OccupiedError<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Send for VacantEntry<'a, K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, F, A> Send for ExtractIf<'a, K, V, F, A>
      where\n    A: Send,\n    F: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T> Send for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Send for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Send for Range<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ +            ["impl<'a, T> Send for SymmetricDifference<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ +            ["impl<'a, T> Send for Union<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ +            ["impl<'a, T> Send for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Send for IterMut<'a, T>
      where\n    T: Send,
      ", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> Send for Drain<'a, T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, A> Send for DrainSorted<'a, T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ +            ["impl<'a, T, A> Send for PeekMut<'a, T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> Send for Difference<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ +            ["impl<'a, T, A> Send for Intersection<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ +            ["impl<'a, T, F, A = Global> !Send for ExtractIf<'a, T, F, A>", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> Send for ExtractIf<'a, T, F, A>
      where\n    A: Send,\n    F: Send,\n    T: Send,
      ", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> Send for ExtractIf<'a, T, F, A>
      where\n    A: Send,\n    F: Send,\n    T: Send,
      ", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ +            ["impl<K, V, A> Send for BTreeMap<K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::BTreeMap"]],
│ │ │ │ │ +            ["impl<K, V, A> Send for IntoIter<K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ +            ["impl<K, V, A> Send for IntoKeys<K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ +            ["impl<K, V, A> Send for IntoValues<K, V, A>
      where\n    A: Send,\n    K: Send,\n    V: Send,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ +            ["impl<T> !Send for UniqueRc<T>", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ +            ["impl<T, A> Send for BinaryHeap<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ +            ["impl<T, A> Send for IntoIter<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Send for IntoIterSorted<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ +            ["impl<T, A> Send for BTreeSet<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ +            ["impl<T, A> Send for IntoIter<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Send for IntoIter<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Send for IntoIter<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Send for VecDeque<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ +            ["impl<T, A> Send for Vec<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ +            ["impl<T: Send> Send for IterMut<'_, T>"],
│ │ │ │ │ +            ["impl<T: Send, A: Allocator + Send> Send for CursorMut<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Send, A: Allocator + Send> Send for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<T: Send, A: Allocator + Send> Send for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Send, A: Allocator + Send> Send for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T: Send, A: Send + Allocator> Send for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Sync> Send for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T: Sync, A: Allocator + Sync> Send for Cursor<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Send> Send for ThinBox<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Sync + Send, A: Allocator + Send> Send for Arc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Sync + Send, A: Allocator + Send> Send for Weak<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A> Send for Box<T, A>
      where\n    A: Send,\n    T: Send,
      ", 1, ["alloc::boxed::Box"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> !Send for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> !Send for Weak<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl !Send for TokenTree"],
│ │ │ │ │              ["impl !Send for Diagnostic", 1, ["proc_macro::diagnostic::Diagnostic"]],
│ │ │ │ │              ["impl !Send for ExpandError"],
│ │ │ │ │              ["impl !Send for Group"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.StructuralPartialEq.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,19 +1,19 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl StructuralPartialEq for TryReserveErrorKind"],
│ │ │ │ │ -            ["impl StructuralPartialEq for UnorderedKeyError"],
│ │ │ │ │ -            ["impl StructuralPartialEq for TryReserveError"],
│ │ │ │ │ -            ["impl StructuralPartialEq for FromVecWithNulError"],
│ │ │ │ │ -            ["impl StructuralPartialEq for IntoStringError"],
│ │ │ │ │ -            ["impl StructuralPartialEq for NulError"],
│ │ │ │ │ -            ["impl StructuralPartialEq for CString"],
│ │ │ │ │ -            ["impl StructuralPartialEq for FromUtf8Error"],
│ │ │ │ │ -            ["impl StructuralPartialEq for String"]
│ │ │ │ │ +            ["impl StructuralPartialEq for TryReserveErrorKind"],
│ │ │ │ │ +            ["impl StructuralPartialEq for UnorderedKeyError"],
│ │ │ │ │ +            ["impl StructuralPartialEq for TryReserveError"],
│ │ │ │ │ +            ["impl StructuralPartialEq for FromVecWithNulError"],
│ │ │ │ │ +            ["impl StructuralPartialEq for IntoStringError"],
│ │ │ │ │ +            ["impl StructuralPartialEq for NulError"],
│ │ │ │ │ +            ["impl StructuralPartialEq for CString"],
│ │ │ │ │ +            ["impl StructuralPartialEq for FromUtf8Error"],
│ │ │ │ │ +            ["impl StructuralPartialEq for String"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl StructuralPartialEq for Delimiter"],
│ │ │ │ │              ["impl StructuralPartialEq for Spacing"]
│ │ │ │ │          ],
│ │ │ │ │          "std": [
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Sync.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,82 +1,82 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Sync for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ -            ["impl Sync for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ -            ["impl Sync for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ -            ["impl Sync for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ -            ["impl Sync for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ -            ["impl Sync for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ -            ["impl Sync for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ -            ["impl Sync for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ -            ["impl Sync for Drain<'_>"],
│ │ │ │ │ -            ["impl Sync for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ -            ["impl Sync for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ -            ["impl Sync for String", 1, ["alloc::string::String"]],
│ │ │ │ │ -            ["impl<'a, B: ?Sized> Sync for Cow<'a, B>
      where\n    B: Sync,\n    <B as ToOwned>::Owned: Sync,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ -            ["impl<'a, I, A> Sync for Splice<'a, I, A>
      where\n    A: Sync,\n    I: Sync,\n    <I as Iterator>::Item: Sync,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ -            ["impl<'a, K, V> Sync for Cursor<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ -            ["impl<'a, K, V> Sync for Iter<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ -            ["impl<'a, K, V> Sync for IterMut<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> Sync for Keys<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ -            ["impl<'a, K, V> Sync for Range<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ -            ["impl<'a, K, V> Sync for RangeMut<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> Sync for Values<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ -            ["impl<'a, K, V> Sync for ValuesMut<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Sync for Entry<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Sync for CursorMut<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Sync for CursorMutKey<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Sync for OccupiedEntry<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Sync for OccupiedError<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Sync for VacantEntry<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, F, A> Sync for ExtractIf<'a, K, V, F, A>
      where\n    A: Sync,\n    F: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T> Sync for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Sync for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Sync for Range<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ -            ["impl<'a, T> Sync for SymmetricDifference<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ -            ["impl<'a, T> Sync for Union<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ -            ["impl<'a, T> Sync for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Sync for IterMut<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> Sync for Drain<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, A> Sync for DrainSorted<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ -            ["impl<'a, T, A> Sync for PeekMut<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> Sync for Difference<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ -            ["impl<'a, T, A> Sync for Intersection<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ -            ["impl<'a, T, F, A = Global> !Sync for ExtractIf<'a, T, F, A>", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> Sync for ExtractIf<'a, T, F, A>
      where\n    A: Sync,\n    F: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> Sync for ExtractIf<'a, T, F, A>
      where\n    A: Sync,\n    F: Sync,\n    T: Sync,
      ", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ -            ["impl<K, V, A> Sync for BTreeMap<K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::BTreeMap"]],
│ │ │ │ │ -            ["impl<K, V, A> Sync for IntoIter<K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ -            ["impl<K, V, A> Sync for IntoKeys<K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ -            ["impl<K, V, A> Sync for IntoValues<K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ -            ["impl<T> !Sync for UniqueRc<T>", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ -            ["impl<T, A> Sync for BinaryHeap<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ -            ["impl<T, A> Sync for IntoIter<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Sync for IntoIterSorted<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ -            ["impl<T, A> Sync for BTreeSet<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ -            ["impl<T, A> Sync for IntoIter<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Sync for IntoIter<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Sync for IntoIter<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Sync for VecDeque<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ -            ["impl<T, A> Sync for Vec<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ -            ["impl<T: Sync> Sync for Iter<'_, T>"],
│ │ │ │ │ -            ["impl<T: Sync> Sync for IterMut<'_, T>"],
│ │ │ │ │ -            ["impl<T: Sync, A: Allocator + Sync> Sync for Cursor<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Sync, A: Allocator + Sync> Sync for CursorMut<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Sync, A: Allocator + Sync> Sync for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<T: Sync, A: Allocator + Sync> Sync for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: Sync, A: Allocator + Sync> Sync for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T: Sync, A: Sync + Allocator> Sync for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Sync + Send, A: Allocator + Sync> Sync for Arc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Sync + Send, A: Allocator + Sync> Sync for Weak<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Sync> Sync for ThinBox<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A> Sync for Box<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::boxed::Box"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> !Sync for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> !Sync for Weak<T, A>"]
│ │ │ │ │ +            ["impl Sync for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ +            ["impl Sync for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ +            ["impl Sync for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ +            ["impl Sync for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ +            ["impl Sync for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ +            ["impl Sync for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ +            ["impl Sync for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ +            ["impl Sync for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ +            ["impl Sync for Drain<'_>"],
│ │ │ │ │ +            ["impl Sync for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ +            ["impl Sync for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ +            ["impl Sync for String", 1, ["alloc::string::String"]],
│ │ │ │ │ +            ["impl<'a, B: ?Sized> Sync for Cow<'a, B>
      where\n    B: Sync,\n    <B as ToOwned>::Owned: Sync,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ +            ["impl<'a, I, A> Sync for Splice<'a, I, A>
      where\n    A: Sync,\n    I: Sync,\n    <I as Iterator>::Item: Sync,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ +            ["impl<'a, K, V> Sync for Cursor<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ +            ["impl<'a, K, V> Sync for Iter<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ +            ["impl<'a, K, V> Sync for IterMut<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> Sync for Keys<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ +            ["impl<'a, K, V> Sync for Range<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ +            ["impl<'a, K, V> Sync for RangeMut<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> Sync for Values<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ +            ["impl<'a, K, V> Sync for ValuesMut<'a, K, V>
      where\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Sync for Entry<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Sync for CursorMut<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Sync for CursorMutKey<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Sync for OccupiedEntry<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Sync for OccupiedError<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Sync for VacantEntry<'a, K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, F, A> Sync for ExtractIf<'a, K, V, F, A>
      where\n    A: Sync,\n    F: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T> Sync for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Sync for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Sync for Range<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ +            ["impl<'a, T> Sync for SymmetricDifference<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ +            ["impl<'a, T> Sync for Union<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ +            ["impl<'a, T> Sync for Iter<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Sync for IterMut<'a, T>
      where\n    T: Sync,
      ", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> Sync for Drain<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, A> Sync for DrainSorted<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ +            ["impl<'a, T, A> Sync for PeekMut<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> Sync for Difference<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ +            ["impl<'a, T, A> Sync for Intersection<'a, T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ +            ["impl<'a, T, F, A = Global> !Sync for ExtractIf<'a, T, F, A>", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> Sync for ExtractIf<'a, T, F, A>
      where\n    A: Sync,\n    F: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> Sync for ExtractIf<'a, T, F, A>
      where\n    A: Sync,\n    F: Sync,\n    T: Sync,
      ", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ +            ["impl<K, V, A> Sync for BTreeMap<K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::BTreeMap"]],
│ │ │ │ │ +            ["impl<K, V, A> Sync for IntoIter<K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ +            ["impl<K, V, A> Sync for IntoKeys<K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ +            ["impl<K, V, A> Sync for IntoValues<K, V, A>
      where\n    A: Sync,\n    K: Sync,\n    V: Sync,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ +            ["impl<T> !Sync for UniqueRc<T>", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ +            ["impl<T, A> Sync for BinaryHeap<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ +            ["impl<T, A> Sync for IntoIter<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Sync for IntoIterSorted<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ +            ["impl<T, A> Sync for BTreeSet<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ +            ["impl<T, A> Sync for IntoIter<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Sync for IntoIter<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Sync for IntoIter<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Sync for VecDeque<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ +            ["impl<T, A> Sync for Vec<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ +            ["impl<T: Sync> Sync for Iter<'_, T>"],
│ │ │ │ │ +            ["impl<T: Sync> Sync for IterMut<'_, T>"],
│ │ │ │ │ +            ["impl<T: Sync, A: Allocator + Sync> Sync for Cursor<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Sync, A: Allocator + Sync> Sync for CursorMut<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Sync, A: Allocator + Sync> Sync for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<T: Sync, A: Allocator + Sync> Sync for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: Sync, A: Allocator + Sync> Sync for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T: Sync, A: Sync + Allocator> Sync for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Sync + Send, A: Allocator + Sync> Sync for Arc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Sync + Send, A: Allocator + Sync> Sync for Weak<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Sync> Sync for ThinBox<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A> Sync for Box<T, A>
      where\n    A: Sync,\n    T: Sync,
      ", 1, ["alloc::boxed::Box"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> !Sync for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> !Sync for Weak<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl !Sync for TokenTree"],
│ │ │ │ │              ["impl !Sync for Diagnostic", 1, ["proc_macro::diagnostic::Diagnostic"]],
│ │ │ │ │              ["impl !Sync for ExpandError"],
│ │ │ │ │              ["impl !Sync for Group"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/marker/trait.Unpin.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,82 +1,82 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Unpin for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ -            ["impl Unpin for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ -            ["impl Unpin for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ -            ["impl Unpin for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ -            ["impl Unpin for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ -            ["impl Unpin for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ -            ["impl Unpin for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ -            ["impl Unpin for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ -            ["impl Unpin for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ -            ["impl Unpin for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ -            ["impl Unpin for String", 1, ["alloc::string::String"]],
│ │ │ │ │ -            ["impl<'a> Unpin for Drain<'a>", 1, ["alloc::string::Drain"]],
│ │ │ │ │ -            ["impl<'a, B: ?Sized> Unpin for Cow<'a, B>
      where\n    <B as ToOwned>::Owned: Unpin,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ -            ["impl<'a, I, A> Unpin for Splice<'a, I, A>
      where\n    I: Unpin,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ -            ["impl<'a, K, V> Unpin for Cursor<'a, K, V>", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ -            ["impl<'a, K, V> Unpin for Iter<'a, K, V>", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ -            ["impl<'a, K, V> Unpin for IterMut<'a, K, V>", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> Unpin for Keys<'a, K, V>", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ -            ["impl<'a, K, V> Unpin for Range<'a, K, V>", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ -            ["impl<'a, K, V> Unpin for RangeMut<'a, K, V>", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> Unpin for Values<'a, K, V>", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ -            ["impl<'a, K, V> Unpin for ValuesMut<'a, K, V>", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Unpin for Entry<'a, K, V, A>
      where\n    A: Unpin,\n    K: Unpin,
      ", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Unpin for CursorMut<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Unpin for CursorMutKey<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Unpin for OccupiedEntry<'a, K, V, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Unpin for OccupiedError<'a, K, V, A>
      where\n    A: Unpin,\n    V: Unpin,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> Unpin for VacantEntry<'a, K, V, A>
      where\n    A: Unpin,\n    K: Unpin,
      ", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, F, A> Unpin for ExtractIf<'a, K, V, F, A>
      where\n    A: Unpin,\n    F: Unpin,
      ", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T> Unpin for Iter<'a, T>", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Unpin for Iter<'a, T>", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Unpin for Range<'a, T>", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ -            ["impl<'a, T> Unpin for SymmetricDifference<'a, T>", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ -            ["impl<'a, T> Unpin for Union<'a, T>", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ -            ["impl<'a, T> Unpin for Iter<'a, T>", 1, ["alloc::collections::linked_list::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Unpin for IterMut<'a, T>", 1, ["alloc::collections::linked_list::IterMut"]],
│ │ │ │ │ -            ["impl<'a, T> Unpin for Iter<'a, T>", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> Unpin for IterMut<'a, T>", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> Unpin for Drain<'a, T, A>", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, A> Unpin for DrainSorted<'a, T, A>", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ -            ["impl<'a, T, A> Unpin for PeekMut<'a, T, A>", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> Unpin for Difference<'a, T, A>", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ -            ["impl<'a, T, A> Unpin for Intersection<'a, T, A>", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ -            ["impl<'a, T, A> Unpin for Cursor<'a, T, A>", 1, ["alloc::collections::linked_list::Cursor"]],
│ │ │ │ │ -            ["impl<'a, T, A> Unpin for CursorMut<'a, T, A>", 1, ["alloc::collections::linked_list::CursorMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> Unpin for Drain<'a, T, A>", 1, ["alloc::collections::vec_deque::drain::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, A> Unpin for Drain<'a, T, A>", 1, ["alloc::vec::drain::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
      where\n    A: Unpin,\n    F: Unpin,
      ", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
      where\n    F: Unpin,
      ", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
      where\n    F: Unpin,
      ", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ -            ["impl<K, V, A> Unpin for BTreeMap<K, V, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::map::BTreeMap"]],
│ │ │ │ │ -            ["impl<K, V, A> Unpin for IntoIter<K, V, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ -            ["impl<K, V, A> Unpin for IntoKeys<K, V, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ -            ["impl<K, V, A> Unpin for IntoValues<K, V, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ -            ["impl<T> Unpin for UniqueRc<T>
      where\n    T: Unpin,
      ", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ -            ["impl<T, A> Unpin for BinaryHeap<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ -            ["impl<T, A> Unpin for IntoIter<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Unpin for IntoIterSorted<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ -            ["impl<T, A> Unpin for BTreeSet<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ -            ["impl<T, A> Unpin for IntoIter<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Unpin for IntoIter<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Unpin for LinkedList<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::linked_list::LinkedList"]],
│ │ │ │ │ -            ["impl<T, A> Unpin for IntoIter<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Unpin for VecDeque<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ -            ["impl<T, A> Unpin for IntoIter<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::vec::into_iter::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> Unpin for Vec<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ -            ["impl<T: ?Sized> Unpin for ThinBox<T>
      where\n    T: Unpin,
      ", 1, ["alloc::boxed::thin::ThinBox"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> Unpin for Weak<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::rc::Weak"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> Unpin for Weak<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::sync::Weak"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Unpin for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Unpin for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Unpin for Arc<T, A>"]
│ │ │ │ │ +            ["impl Unpin for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ +            ["impl Unpin for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ +            ["impl Unpin for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ +            ["impl Unpin for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ +            ["impl Unpin for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ +            ["impl Unpin for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ +            ["impl Unpin for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ +            ["impl Unpin for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ +            ["impl Unpin for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ +            ["impl Unpin for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ +            ["impl Unpin for String", 1, ["alloc::string::String"]],
│ │ │ │ │ +            ["impl<'a> Unpin for Drain<'a>", 1, ["alloc::string::Drain"]],
│ │ │ │ │ +            ["impl<'a, B: ?Sized> Unpin for Cow<'a, B>
      where\n    <B as ToOwned>::Owned: Unpin,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ +            ["impl<'a, I, A> Unpin for Splice<'a, I, A>
      where\n    I: Unpin,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ +            ["impl<'a, K, V> Unpin for Cursor<'a, K, V>", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ +            ["impl<'a, K, V> Unpin for Iter<'a, K, V>", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ +            ["impl<'a, K, V> Unpin for IterMut<'a, K, V>", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> Unpin for Keys<'a, K, V>", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ +            ["impl<'a, K, V> Unpin for Range<'a, K, V>", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ +            ["impl<'a, K, V> Unpin for RangeMut<'a, K, V>", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> Unpin for Values<'a, K, V>", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ +            ["impl<'a, K, V> Unpin for ValuesMut<'a, K, V>", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Unpin for Entry<'a, K, V, A>
      where\n    A: Unpin,\n    K: Unpin,
      ", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Unpin for CursorMut<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Unpin for CursorMutKey<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Unpin for OccupiedEntry<'a, K, V, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Unpin for OccupiedError<'a, K, V, A>
      where\n    A: Unpin,\n    V: Unpin,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> Unpin for VacantEntry<'a, K, V, A>
      where\n    A: Unpin,\n    K: Unpin,
      ", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, F, A> Unpin for ExtractIf<'a, K, V, F, A>
      where\n    A: Unpin,\n    F: Unpin,
      ", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T> Unpin for Iter<'a, T>", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Unpin for Iter<'a, T>", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Unpin for Range<'a, T>", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ +            ["impl<'a, T> Unpin for SymmetricDifference<'a, T>", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ +            ["impl<'a, T> Unpin for Union<'a, T>", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ +            ["impl<'a, T> Unpin for Iter<'a, T>", 1, ["alloc::collections::linked_list::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Unpin for IterMut<'a, T>", 1, ["alloc::collections::linked_list::IterMut"]],
│ │ │ │ │ +            ["impl<'a, T> Unpin for Iter<'a, T>", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> Unpin for IterMut<'a, T>", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> Unpin for Drain<'a, T, A>", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, A> Unpin for DrainSorted<'a, T, A>", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ +            ["impl<'a, T, A> Unpin for PeekMut<'a, T, A>", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> Unpin for Difference<'a, T, A>", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ +            ["impl<'a, T, A> Unpin for Intersection<'a, T, A>", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ +            ["impl<'a, T, A> Unpin for Cursor<'a, T, A>", 1, ["alloc::collections::linked_list::Cursor"]],
│ │ │ │ │ +            ["impl<'a, T, A> Unpin for CursorMut<'a, T, A>", 1, ["alloc::collections::linked_list::CursorMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> Unpin for Drain<'a, T, A>", 1, ["alloc::collections::vec_deque::drain::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, A> Unpin for Drain<'a, T, A>", 1, ["alloc::vec::drain::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
      where\n    A: Unpin,\n    F: Unpin,
      ", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
      where\n    F: Unpin,
      ", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> Unpin for ExtractIf<'a, T, F, A>
      where\n    F: Unpin,
      ", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ +            ["impl<K, V, A> Unpin for BTreeMap<K, V, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::map::BTreeMap"]],
│ │ │ │ │ +            ["impl<K, V, A> Unpin for IntoIter<K, V, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ +            ["impl<K, V, A> Unpin for IntoKeys<K, V, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ +            ["impl<K, V, A> Unpin for IntoValues<K, V, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ +            ["impl<T> Unpin for UniqueRc<T>
      where\n    T: Unpin,
      ", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ +            ["impl<T, A> Unpin for BinaryHeap<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ +            ["impl<T, A> Unpin for IntoIter<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Unpin for IntoIterSorted<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ +            ["impl<T, A> Unpin for BTreeSet<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ +            ["impl<T, A> Unpin for IntoIter<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Unpin for IntoIter<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Unpin for LinkedList<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::collections::linked_list::LinkedList"]],
│ │ │ │ │ +            ["impl<T, A> Unpin for IntoIter<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Unpin for VecDeque<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ +            ["impl<T, A> Unpin for IntoIter<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::vec::into_iter::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> Unpin for Vec<T, A>
      where\n    A: Unpin,\n    T: Unpin,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ +            ["impl<T: ?Sized> Unpin for ThinBox<T>
      where\n    T: Unpin,
      ", 1, ["alloc::boxed::thin::ThinBox"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> Unpin for Weak<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::rc::Weak"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> Unpin for Weak<T, A>
      where\n    A: Unpin,
      ", 1, ["alloc::sync::Weak"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Unpin for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Unpin for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Unpin for Arc<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl Unpin for Delimiter", 1, ["proc_macro::Delimiter"]],
│ │ │ │ │              ["impl Unpin for Level", 1, ["proc_macro::diagnostic::Level"]],
│ │ │ │ │              ["impl Unpin for Spacing", 1, ["proc_macro::Spacing"]],
│ │ │ │ │              ["impl Unpin for TokenTree", 1, ["proc_macro::TokenTree"]],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.Add.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,13 +1,13 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Add<&str> for String"],
│ │ │ │ │ -            ["impl<'a> Add for Cow<'a, str>"],
│ │ │ │ │ -            ["impl<'a> Add<&'a str> for Cow<'a, str>"]
│ │ │ │ │ +            ["impl Add<&str> for String"],
│ │ │ │ │ +            ["impl<'a> Add for Cow<'a, str>"],
│ │ │ │ │ +            ["impl<'a> Add<&'a str> for Cow<'a, str>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl Add<Duration> for Instant"],
│ │ │ │ │              ["impl Add<Duration> for SystemTime"]
│ │ │ │ │          ]
│ │ │ │ │      };
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.AddAssign.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,13 +1,13 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl AddAssign<&str> for String"],
│ │ │ │ │ -            ["impl<'a> AddAssign for Cow<'a, str>"],
│ │ │ │ │ -            ["impl<'a> AddAssign<&'a str> for Cow<'a, str>"]
│ │ │ │ │ +            ["impl AddAssign<&str> for String"],
│ │ │ │ │ +            ["impl<'a> AddAssign for Cow<'a, str>"],
│ │ │ │ │ +            ["impl<'a> AddAssign<&'a str> for Cow<'a, str>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl AddAssign<Duration> for Instant"],
│ │ │ │ │              ["impl AddAssign<Duration> for SystemTime"]
│ │ │ │ │          ]
│ │ │ │ │      };
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/arith/trait.Sub.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<T: Ord + Clone, A: Allocator + Clone> Sub<&BTreeSet<T, A>> for &BTreeSet<T, A>"]
│ │ │ │ │ +            ["impl<T: Ord + Clone, A: Allocator + Clone> Sub<&BTreeSet<T, A>> for &BTreeSet<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl Sub for Instant"],
│ │ │ │ │              ["impl Sub<Duration> for Instant"],
│ │ │ │ │              ["impl Sub<Duration> for SystemTime"],
│ │ │ │ │              ["impl<T, S> Sub<&HashSet<T, S>> for &HashSet<T, S>
      where\n    T: Eq + Hash + Clone,\n    S: BuildHasher + Default,
      "]
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/async_function/trait.AsyncFn.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<Args: Tuple, F: AsyncFn<Args> + ?Sized, A: Allocator> AsyncFn<Args> for Box<F, A>"]
│ │ │ │ │ +            ["impl<Args: Tuple, F: AsyncFn<Args> + ?Sized, A: Allocator> AsyncFn<Args> for Box<F, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/async_function/trait.AsyncFnMut.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<Args: Tuple, F: AsyncFnMut<Args> + ?Sized, A: Allocator> AsyncFnMut<Args> for Box<F, A>"]
│ │ │ │ │ +            ["impl<Args: Tuple, F: AsyncFnMut<Args> + ?Sized, A: Allocator> AsyncFnMut<Args> for Box<F, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/async_function/trait.AsyncFnOnce.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<Args: Tuple, F: AsyncFnOnce<Args> + ?Sized, A: Allocator> AsyncFnOnce<Args> for Box<F, A>"]
│ │ │ │ │ +            ["impl<Args: Tuple, F: AsyncFnOnce<Args> + ?Sized, A: Allocator> AsyncFnOnce<Args> for Box<F, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitAnd.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<T: Ord + Clone, A: Allocator + Clone> BitAnd<&BTreeSet<T, A>> for &BTreeSet<T, A>"]
│ │ │ │ │ +            ["impl<T: Ord + Clone, A: Allocator + Clone> BitAnd<&BTreeSet<T, A>> for &BTreeSet<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl<T, S> BitAnd<&HashSet<T, S>> for &HashSet<T, S>
      where\n    T: Eq + Hash + Clone,\n    S: BuildHasher + Default,
      "]
│ │ │ │ │          ]
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitOr.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<T: Ord + Clone, A: Allocator + Clone> BitOr<&BTreeSet<T, A>> for &BTreeSet<T, A>"]
│ │ │ │ │ +            ["impl<T: Ord + Clone, A: Allocator + Clone> BitOr<&BTreeSet<T, A>> for &BTreeSet<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl<T, S> BitOr<&HashSet<T, S>> for &HashSet<T, S>
      where\n    T: Eq + Hash + Clone,\n    S: BuildHasher + Default,
      "]
│ │ │ │ │          ]
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/bit/trait.BitXor.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<T: Ord + Clone, A: Allocator + Clone> BitXor<&BTreeSet<T, A>> for &BTreeSet<T, A>"]
│ │ │ │ │ +            ["impl<T: Ord + Clone, A: Allocator + Clone> BitXor<&BTreeSet<T, A>> for &BTreeSet<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl<T, S> BitXor<&HashSet<T, S>> for &HashSet<T, S>
      where\n    T: Eq + Hash + Clone,\n    S: BuildHasher + Default,
      "]
│ │ │ │ │          ]
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/coroutine/trait.Coroutine.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,12 +1,12 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<G: ?Sized + Coroutine<R> + Unpin, R, A: Allocator> Coroutine<R> for Box<G, A>"],
│ │ │ │ │ -            ["impl<G: ?Sized + Coroutine<R>, R, A> Coroutine<R> for Pin<Box<G, A>>
      where\n    A: 'static + Allocator,
      "]
│ │ │ │ │ +            ["impl<G: ?Sized + Coroutine<R> + Unpin, R, A: Allocator> Coroutine<R> for Box<G, A>"],
│ │ │ │ │ +            ["impl<G: ?Sized + Coroutine<R>, R, A> Coroutine<R> for Pin<Box<G, A>>
      where\n    A: 'static + Allocator,
      "]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/deref/trait.Deref.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,20 +1,20 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Deref for CString"],
│ │ │ │ │ -            ["impl Deref for String"],
│ │ │ │ │ -            ["impl<B: ?Sized + ToOwned> Deref for Cow<'_, B>
      where\n    B::Owned: Borrow<B>,
      "],
│ │ │ │ │ -            ["impl<T> Deref for UniqueRc<T>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Deref for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> Deref for PeekMut<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized> Deref for ThinBox<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Deref for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Deref for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Deref for Arc<T, A>"]
│ │ │ │ │ +            ["impl Deref for CString"],
│ │ │ │ │ +            ["impl Deref for String"],
│ │ │ │ │ +            ["impl<B: ?Sized + ToOwned> Deref for Cow<'_, B>
      where\n    B::Owned: Borrow<B>,
      "],
│ │ │ │ │ +            ["impl<T> Deref for UniqueRc<T>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Deref for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> Deref for PeekMut<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized> Deref for ThinBox<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Deref for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Deref for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Deref for Arc<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl Deref for OsString"],
│ │ │ │ │              ["impl Deref for PathBuf"],
│ │ │ │ │              ["impl<'a> Deref for IoSlice<'a>"],
│ │ │ │ │              ["impl<'a> Deref for IoSliceMut<'a>"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/deref/trait.DerefMut.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,16 +1,16 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl DerefMut for String"],
│ │ │ │ │ -            ["impl<T> DerefMut for UniqueRc<T>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> DerefMut for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> DerefMut for PeekMut<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized> DerefMut for ThinBox<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> DerefMut for Box<T, A>"]
│ │ │ │ │ +            ["impl DerefMut for String"],
│ │ │ │ │ +            ["impl<T> DerefMut for UniqueRc<T>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> DerefMut for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> DerefMut for PeekMut<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized> DerefMut for ThinBox<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> DerefMut for Box<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl DerefMut for OsString"],
│ │ │ │ │              ["impl DerefMut for PathBuf"],
│ │ │ │ │              ["impl<'a> DerefMut for IoSliceMut<'a>"],
│ │ │ │ │              ["impl<T: ?Sized> DerefMut for MappedMutexGuard<'_, T>"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/drop/trait.Drop.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,31 +1,31 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Drop for CString"],
│ │ │ │ │ -            ["impl Drop for Drain<'_>"],
│ │ │ │ │ -            ["impl<'a, T: Ord, A: Allocator> Drop for DrainSorted<'a, T, A>"],
│ │ │ │ │ -            ["impl<I: Iterator, A: Allocator> Drop for Splice<'_, I, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> Drop for BTreeMap<K, V, A>"],
│ │ │ │ │ -            ["impl<K, V, A: Allocator + Clone> Drop for IntoIter<K, V, A>"],
│ │ │ │ │ -            ["impl<T> Drop for UniqueRc<T>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Drop for LinkedList<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Drop for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Drop for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Drop for Drain<'_, T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Drop for IntoIter<T, A>"],
│ │ │ │ │ -            ["impl<T, A: Allocator> Drop for Vec<T, A>"],
│ │ │ │ │ -            ["impl<T, F, A: Allocator> Drop for ExtractIf<'_, T, F, A>
      where\n    F: FnMut(&mut T) -> bool,
      "],
│ │ │ │ │ -            ["impl<T: Ord, A: Allocator> Drop for PeekMut<'_, T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized> Drop for ThinBox<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Drop for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Drop for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Drop for Weak<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Drop for Arc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized, A: Allocator> Drop for Weak<T, A>"]
│ │ │ │ │ +            ["impl Drop for CString"],
│ │ │ │ │ +            ["impl Drop for Drain<'_>"],
│ │ │ │ │ +            ["impl<'a, T: Ord, A: Allocator> Drop for DrainSorted<'a, T, A>"],
│ │ │ │ │ +            ["impl<I: Iterator, A: Allocator> Drop for Splice<'_, I, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> Drop for BTreeMap<K, V, A>"],
│ │ │ │ │ +            ["impl<K, V, A: Allocator + Clone> Drop for IntoIter<K, V, A>"],
│ │ │ │ │ +            ["impl<T> Drop for UniqueRc<T>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Drop for LinkedList<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Drop for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Drop for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Drop for Drain<'_, T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Drop for IntoIter<T, A>"],
│ │ │ │ │ +            ["impl<T, A: Allocator> Drop for Vec<T, A>"],
│ │ │ │ │ +            ["impl<T, F, A: Allocator> Drop for ExtractIf<'_, T, F, A>
      where\n    F: FnMut(&mut T) -> bool,
      "],
│ │ │ │ │ +            ["impl<T: Ord, A: Allocator> Drop for PeekMut<'_, T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized> Drop for ThinBox<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Drop for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Drop for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Drop for Weak<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Drop for Arc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized, A: Allocator> Drop for Weak<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl Drop for OwnedFd"],
│ │ │ │ │              ["impl Drop for HandleOrInvalid"],
│ │ │ │ │              ["impl Drop for HandleOrNull"],
│ │ │ │ │              ["impl Drop for OwnedHandle"],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/function/trait.Fn.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<Args: Tuple, F: Fn<Args> + ?Sized, A: Allocator> Fn<Args> for Box<F, A>"]
│ │ │ │ │ +            ["impl<Args: Tuple, F: Fn<Args> + ?Sized, A: Allocator> Fn<Args> for Box<F, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/function/trait.FnMut.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<Args: Tuple, F: FnMut<Args> + ?Sized, A: Allocator> FnMut<Args> for Box<F, A>"]
│ │ │ │ │ +            ["impl<Args: Tuple, F: FnMut<Args> + ?Sized, A: Allocator> FnMut<Args> for Box<F, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/function/trait.FnOnce.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,11 +1,11 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<Args: Tuple, F: FnOnce<Args> + ?Sized, A: Allocator> FnOnce<Args> for Box<F, A>"]
│ │ │ │ │ +            ["impl<Args: Tuple, F: FnOnce<Args> + ?Sized, A: Allocator> FnOnce<Args> for Box<F, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/index/trait.Index.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl Index<RangeFull> for CString"],
│ │ │ │ │ -            ["impl<I> Index<I> for String
      where\n    I: SliceIndex<str>,
      "],
│ │ │ │ │ -            ["impl<K, Q, V, A: Allocator + Clone> Index<&Q> for BTreeMap<K, V, A>
      where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
      "],
│ │ │ │ │ -            ["impl<T, A: Allocator> Index<usize> for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T, I: SliceIndex<[T]>, A: Allocator> Index<I> for Vec<T, A>"]
│ │ │ │ │ +            ["impl Index<RangeFull> for CString"],
│ │ │ │ │ +            ["impl<I> Index<I> for String
      where\n    I: SliceIndex<str>,
      "],
│ │ │ │ │ +            ["impl<K, Q, V, A: Allocator + Clone> Index<&Q> for BTreeMap<K, V, A>
      where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
      "],
│ │ │ │ │ +            ["impl<T, A: Allocator> Index<usize> for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T, I: SliceIndex<[T]>, A: Allocator> Index<I> for Vec<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl Index<RangeFull> for OsString"],
│ │ │ │ │              ["impl<K, Q, V, S> Index<&Q> for HashMap<K, V, S>
      where\n    K: Eq + Hash + Borrow<Q>,\n    Q: Eq + Hash + ?Sized,\n    S: BuildHasher,
      "]
│ │ │ │ │          ]
│ │ │ │ │      };
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/index/trait.IndexMut.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,13 +1,13 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<I> IndexMut<I> for String
      where\n    I: SliceIndex<str>,
      "],
│ │ │ │ │ -            ["impl<T, A: Allocator> IndexMut<usize> for VecDeque<T, A>"],
│ │ │ │ │ -            ["impl<T, I: SliceIndex<[T]>, A: Allocator> IndexMut<I> for Vec<T, A>"]
│ │ │ │ │ +            ["impl<I> IndexMut<I> for String
      where\n    I: SliceIndex<str>,
      "],
│ │ │ │ │ +            ["impl<T, A: Allocator> IndexMut<usize> for VecDeque<T, A>"],
│ │ │ │ │ +            ["impl<T, I: SliceIndex<[T]>, A: Allocator> IndexMut<I> for Vec<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": [
│ │ │ │ │              ["impl IndexMut<RangeFull> for OsString"]
│ │ │ │ │          ]
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/unsize/trait.CoerceUnsized.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Box<U, A>> for Box<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Rc<U, A>> for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Weak<U, A>> for Weak<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Arc<U, A>> for Arc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Weak<U, A>> for Weak<T, A>"]
│ │ │ │ │ +            ["impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Box<U, A>> for Box<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Rc<U, A>> for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Weak<U, A>> for Weak<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Arc<U, A>> for Arc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Weak<U, A>> for Weak<T, A>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/ops/unsize/trait.DispatchFromDyn.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Box<U>> for Box<T, Global>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Rc<U>> for Rc<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Arc<U>> for Arc<T>"],
│ │ │ │ │ -            ["impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T>"]
│ │ │ │ │ +            ["impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Box<U>> for Box<T, Global>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Rc<U>> for Rc<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Arc<U>> for Arc<T>"],
│ │ │ │ │ +            ["impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T>"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "std": []
│ │ │ │ │      };
│ │ │ │ │      if (window.register_implementors) {
│ │ │ │ │          window.register_implementors(implementors);
│ │ │ │ │      } else {
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,82 +1,82 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl RefUnwindSafe for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ -            ["impl RefUnwindSafe for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ -            ["impl RefUnwindSafe for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ -            ["impl RefUnwindSafe for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ -            ["impl RefUnwindSafe for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ -            ["impl RefUnwindSafe for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ -            ["impl RefUnwindSafe for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ -            ["impl RefUnwindSafe for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ -            ["impl RefUnwindSafe for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ -            ["impl RefUnwindSafe for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ -            ["impl RefUnwindSafe for String", 1, ["alloc::string::String"]],
│ │ │ │ │ -            ["impl<'a> RefUnwindSafe for Drain<'a>", 1, ["alloc::string::Drain"]],
│ │ │ │ │ -            ["impl<'a, B: ?Sized> RefUnwindSafe for Cow<'a, B>
      where\n    B: RefUnwindSafe,\n    <B as ToOwned>::Owned: RefUnwindSafe,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ -            ["impl<'a, I, A> RefUnwindSafe for Splice<'a, I, A>
      where\n    A: RefUnwindSafe,\n    I: RefUnwindSafe,\n    <I as Iterator>::Item: RefUnwindSafe,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ -            ["impl<'a, K, V> RefUnwindSafe for Cursor<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ -            ["impl<'a, K, V> RefUnwindSafe for Iter<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ -            ["impl<'a, K, V> RefUnwindSafe for IterMut<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> RefUnwindSafe for Keys<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ -            ["impl<'a, K, V> RefUnwindSafe for Range<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ -            ["impl<'a, K, V> RefUnwindSafe for RangeMut<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> RefUnwindSafe for Values<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ -            ["impl<'a, K, V> RefUnwindSafe for ValuesMut<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> RefUnwindSafe for Entry<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> RefUnwindSafe for CursorMut<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> RefUnwindSafe for CursorMutKey<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> RefUnwindSafe for OccupiedEntry<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> RefUnwindSafe for OccupiedError<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ -            ["impl<'a, K, V, A> RefUnwindSafe for VacantEntry<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, F, A> RefUnwindSafe for ExtractIf<'a, K, V, F, A>
      where\n    A: RefUnwindSafe,\n    F: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T> RefUnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> RefUnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> RefUnwindSafe for Range<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ -            ["impl<'a, T> RefUnwindSafe for SymmetricDifference<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ -            ["impl<'a, T> RefUnwindSafe for Union<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ -            ["impl<'a, T> RefUnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> RefUnwindSafe for IterMut<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::IterMut"]],
│ │ │ │ │ -            ["impl<'a, T> RefUnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> RefUnwindSafe for IterMut<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, A> RefUnwindSafe for DrainSorted<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ -            ["impl<'a, T, A> RefUnwindSafe for PeekMut<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> RefUnwindSafe for Difference<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ -            ["impl<'a, T, A> RefUnwindSafe for Intersection<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ -            ["impl<'a, T, A> RefUnwindSafe for Cursor<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::Cursor"]],
│ │ │ │ │ -            ["impl<'a, T, A> RefUnwindSafe for CursorMut<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::CursorMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::drain::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::vec::drain::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
      where\n    A: RefUnwindSafe,\n    F: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
      where\n    A: RefUnwindSafe,\n    F: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
      where\n    A: RefUnwindSafe,\n    F: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ -            ["impl<K, V, A> RefUnwindSafe for BTreeMap<K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::BTreeMap"]],
│ │ │ │ │ -            ["impl<K, V, A> RefUnwindSafe for IntoIter<K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ -            ["impl<K, V, A> RefUnwindSafe for IntoKeys<K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ -            ["impl<K, V, A> RefUnwindSafe for IntoValues<K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ -            ["impl<T> !RefUnwindSafe for UniqueRc<T>", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ -            ["impl<T, A = Global> !RefUnwindSafe for Weak<T, A>", 1, ["alloc::rc::Weak"]],
│ │ │ │ │ -            ["impl<T, A> RefUnwindSafe for BinaryHeap<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ -            ["impl<T, A> RefUnwindSafe for IntoIter<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> RefUnwindSafe for IntoIterSorted<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ -            ["impl<T, A> RefUnwindSafe for BTreeSet<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ -            ["impl<T, A> RefUnwindSafe for IntoIter<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> RefUnwindSafe for IntoIter<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> RefUnwindSafe for LinkedList<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::LinkedList"]],
│ │ │ │ │ -            ["impl<T, A> RefUnwindSafe for IntoIter<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> RefUnwindSafe for VecDeque<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ -            ["impl<T, A> RefUnwindSafe for IntoIter<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::vec::into_iter::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> RefUnwindSafe for Vec<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ -            ["impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> RefUnwindSafe for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized> RefUnwindSafe for ThinBox<T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::boxed::thin::ThinBox"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> RefUnwindSafe for Box<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::boxed::Box"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> RefUnwindSafe for Arc<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::sync::Arc"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> RefUnwindSafe for Weak<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::sync::Weak"]]
│ │ │ │ │ +            ["impl RefUnwindSafe for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ +            ["impl RefUnwindSafe for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ +            ["impl RefUnwindSafe for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ +            ["impl RefUnwindSafe for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ +            ["impl RefUnwindSafe for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ +            ["impl RefUnwindSafe for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ +            ["impl RefUnwindSafe for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ +            ["impl RefUnwindSafe for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ +            ["impl RefUnwindSafe for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ +            ["impl RefUnwindSafe for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ +            ["impl RefUnwindSafe for String", 1, ["alloc::string::String"]],
│ │ │ │ │ +            ["impl<'a> RefUnwindSafe for Drain<'a>", 1, ["alloc::string::Drain"]],
│ │ │ │ │ +            ["impl<'a, B: ?Sized> RefUnwindSafe for Cow<'a, B>
      where\n    B: RefUnwindSafe,\n    <B as ToOwned>::Owned: RefUnwindSafe,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ +            ["impl<'a, I, A> RefUnwindSafe for Splice<'a, I, A>
      where\n    A: RefUnwindSafe,\n    I: RefUnwindSafe,\n    <I as Iterator>::Item: RefUnwindSafe,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ +            ["impl<'a, K, V> RefUnwindSafe for Cursor<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ +            ["impl<'a, K, V> RefUnwindSafe for Iter<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ +            ["impl<'a, K, V> RefUnwindSafe for IterMut<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> RefUnwindSafe for Keys<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ +            ["impl<'a, K, V> RefUnwindSafe for Range<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ +            ["impl<'a, K, V> RefUnwindSafe for RangeMut<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> RefUnwindSafe for Values<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ +            ["impl<'a, K, V> RefUnwindSafe for ValuesMut<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> RefUnwindSafe for Entry<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> RefUnwindSafe for CursorMut<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> RefUnwindSafe for CursorMutKey<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> RefUnwindSafe for OccupiedEntry<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> RefUnwindSafe for OccupiedError<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ +            ["impl<'a, K, V, A> RefUnwindSafe for VacantEntry<'a, K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, F, A> RefUnwindSafe for ExtractIf<'a, K, V, F, A>
      where\n    A: RefUnwindSafe,\n    F: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T> RefUnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> RefUnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> RefUnwindSafe for Range<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ +            ["impl<'a, T> RefUnwindSafe for SymmetricDifference<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ +            ["impl<'a, T> RefUnwindSafe for Union<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ +            ["impl<'a, T> RefUnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> RefUnwindSafe for IterMut<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::IterMut"]],
│ │ │ │ │ +            ["impl<'a, T> RefUnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> RefUnwindSafe for IterMut<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, A> RefUnwindSafe for DrainSorted<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ +            ["impl<'a, T, A> RefUnwindSafe for PeekMut<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> RefUnwindSafe for Difference<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ +            ["impl<'a, T, A> RefUnwindSafe for Intersection<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ +            ["impl<'a, T, A> RefUnwindSafe for Cursor<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::Cursor"]],
│ │ │ │ │ +            ["impl<'a, T, A> RefUnwindSafe for CursorMut<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::CursorMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::drain::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, A> RefUnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::vec::drain::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
      where\n    A: RefUnwindSafe,\n    F: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
      where\n    A: RefUnwindSafe,\n    F: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A> RefUnwindSafe for ExtractIf<'a, T, F, A>
      where\n    A: RefUnwindSafe,\n    F: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ +            ["impl<K, V, A> RefUnwindSafe for BTreeMap<K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::BTreeMap"]],
│ │ │ │ │ +            ["impl<K, V, A> RefUnwindSafe for IntoIter<K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ +            ["impl<K, V, A> RefUnwindSafe for IntoKeys<K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ +            ["impl<K, V, A> RefUnwindSafe for IntoValues<K, V, A>
      where\n    A: RefUnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ +            ["impl<T> !RefUnwindSafe for UniqueRc<T>", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ +            ["impl<T, A = Global> !RefUnwindSafe for Weak<T, A>", 1, ["alloc::rc::Weak"]],
│ │ │ │ │ +            ["impl<T, A> RefUnwindSafe for BinaryHeap<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ +            ["impl<T, A> RefUnwindSafe for IntoIter<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> RefUnwindSafe for IntoIterSorted<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ +            ["impl<T, A> RefUnwindSafe for BTreeSet<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ +            ["impl<T, A> RefUnwindSafe for IntoIter<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> RefUnwindSafe for IntoIter<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> RefUnwindSafe for LinkedList<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::LinkedList"]],
│ │ │ │ │ +            ["impl<T, A> RefUnwindSafe for IntoIter<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> RefUnwindSafe for VecDeque<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ +            ["impl<T, A> RefUnwindSafe for IntoIter<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::vec::into_iter::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> RefUnwindSafe for Vec<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ +            ["impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> RefUnwindSafe for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized> RefUnwindSafe for ThinBox<T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::boxed::thin::ThinBox"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> RefUnwindSafe for Box<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::boxed::Box"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> RefUnwindSafe for Arc<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::sync::Arc"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> RefUnwindSafe for Weak<T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::sync::Weak"]]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl RefUnwindSafe for Delimiter", 1, ["proc_macro::Delimiter"]],
│ │ │ │ │              ["impl RefUnwindSafe for Level", 1, ["proc_macro::diagnostic::Level"]],
│ │ │ │ │              ["impl RefUnwindSafe for Spacing", 1, ["proc_macro::Spacing"]],
│ │ │ │ │              ["impl RefUnwindSafe for TokenTree", 1, ["proc_macro::TokenTree"]],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,82 +1,82 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var implementors = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["impl UnwindSafe for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ -            ["impl UnwindSafe for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ -            ["impl UnwindSafe for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ -            ["impl UnwindSafe for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ -            ["impl UnwindSafe for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ -            ["impl UnwindSafe for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ -            ["impl UnwindSafe for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ -            ["impl UnwindSafe for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ -            ["impl UnwindSafe for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ -            ["impl UnwindSafe for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ -            ["impl UnwindSafe for String", 1, ["alloc::string::String"]],
│ │ │ │ │ -            ["impl<'a> UnwindSafe for Drain<'a>", 1, ["alloc::string::Drain"]],
│ │ │ │ │ -            ["impl<'a, B: ?Sized> UnwindSafe for Cow<'a, B>
      where\n    B: RefUnwindSafe,\n    <B as ToOwned>::Owned: UnwindSafe,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ -            ["impl<'a, I, A> UnwindSafe for Splice<'a, I, A>
      where\n    A: RefUnwindSafe,\n    I: UnwindSafe,\n    <I as Iterator>::Item: RefUnwindSafe,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ -            ["impl<'a, K, V> !UnwindSafe for IterMut<'a, K, V>", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> !UnwindSafe for RangeMut<'a, K, V>", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> !UnwindSafe for ValuesMut<'a, K, V>", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ -            ["impl<'a, K, V> UnwindSafe for Cursor<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ -            ["impl<'a, K, V> UnwindSafe for Iter<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ -            ["impl<'a, K, V> UnwindSafe for Keys<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ -            ["impl<'a, K, V> UnwindSafe for Range<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ -            ["impl<'a, K, V> UnwindSafe for Values<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ -            ["impl<'a, K, V, A = Global> !UnwindSafe for Entry<'a, K, V, A>", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A = Global> !UnwindSafe for CursorMut<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ -            ["impl<'a, K, V, A = Global> !UnwindSafe for CursorMutKey<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ -            ["impl<'a, K, V, A = Global> !UnwindSafe for OccupiedEntry<'a, K, V, A>", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, A = Global> !UnwindSafe for OccupiedError<'a, K, V, A>", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ -            ["impl<'a, K, V, A = Global> !UnwindSafe for VacantEntry<'a, K, V, A>", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ -            ["impl<'a, K, V, F, A = Global> !UnwindSafe for ExtractIf<'a, K, V, F, A>", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T> !UnwindSafe for IterMut<'a, T>", 1, ["alloc::collections::linked_list::IterMut"]],
│ │ │ │ │ -            ["impl<'a, T> !UnwindSafe for IterMut<'a, T>", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ -            ["impl<'a, T> UnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> UnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> UnwindSafe for Range<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ -            ["impl<'a, T> UnwindSafe for SymmetricDifference<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ -            ["impl<'a, T> UnwindSafe for Union<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ -            ["impl<'a, T> UnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::Iter"]],
│ │ │ │ │ -            ["impl<'a, T> UnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ -            ["impl<'a, T, A = Global> !UnwindSafe for DrainSorted<'a, T, A>", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ -            ["impl<'a, T, A = Global> !UnwindSafe for PeekMut<'a, T, A>", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ -            ["impl<'a, T, A = Global> !UnwindSafe for CursorMut<'a, T, A>", 1, ["alloc::collections::linked_list::CursorMut"]],
│ │ │ │ │ -            ["impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, A> UnwindSafe for Difference<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ -            ["impl<'a, T, A> UnwindSafe for Intersection<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ -            ["impl<'a, T, A> UnwindSafe for Cursor<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::Cursor"]],
│ │ │ │ │ -            ["impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::drain::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::vec::drain::Drain"]],
│ │ │ │ │ -            ["impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ -            ["impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ -            ["impl<K, V, A> UnwindSafe for BTreeMap<K, V, A>
      where\n    A: UnwindSafe + Allocator + Clone,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      "],
│ │ │ │ │ -            ["impl<K, V, A> UnwindSafe for IntoIter<K, V, A>
      where\n    A: UnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ -            ["impl<K, V, A> UnwindSafe for IntoKeys<K, V, A>
      where\n    A: UnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ -            ["impl<K, V, A> UnwindSafe for IntoValues<K, V, A>
      where\n    A: UnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ -            ["impl<T> !UnwindSafe for UniqueRc<T>", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ -            ["impl<T, A = Global> !UnwindSafe for Weak<T, A>", 1, ["alloc::rc::Weak"]],
│ │ │ │ │ -            ["impl<T, A> UnwindSafe for BinaryHeap<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ -            ["impl<T, A> UnwindSafe for IntoIter<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe + RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> UnwindSafe for IntoIterSorted<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ -            ["impl<T, A> UnwindSafe for BTreeSet<T, A>
      where\n    A: UnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ -            ["impl<T, A> UnwindSafe for IntoIter<T, A>
      where\n    A: UnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> UnwindSafe for IntoIter<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe + RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> UnwindSafe for LinkedList<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe + RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::LinkedList"]],
│ │ │ │ │ -            ["impl<T, A> UnwindSafe for IntoIter<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> UnwindSafe for VecDeque<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ -            ["impl<T, A> UnwindSafe for IntoIter<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe + RefUnwindSafe,
      ", 1, ["alloc::vec::into_iter::IntoIter"]],
│ │ │ │ │ -            ["impl<T, A> UnwindSafe for Vec<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ -            ["impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> UnwindSafe for Rc<T, A>"],
│ │ │ │ │ -            ["impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> UnwindSafe for Arc<T, A>"],
│ │ │ │ │ -            ["impl<T: ?Sized> UnwindSafe for ThinBox<T>
      where\n    T: UnwindSafe,
      ", 1, ["alloc::boxed::thin::ThinBox"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> UnwindSafe for Box<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::boxed::Box"]],
│ │ │ │ │ -            ["impl<T: ?Sized, A> UnwindSafe for Weak<T, A>
      where\n    A: UnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::sync::Weak"]]
│ │ │ │ │ +            ["impl UnwindSafe for TryReserveErrorKind", 1, ["alloc::collections::TryReserveErrorKind"]],
│ │ │ │ │ +            ["impl UnwindSafe for Global", 1, ["alloc::alloc::Global"]],
│ │ │ │ │ +            ["impl UnwindSafe for UnorderedKeyError", 1, ["alloc::collections::btree::map::UnorderedKeyError"]],
│ │ │ │ │ +            ["impl UnwindSafe for TryReserveError", 1, ["alloc::collections::TryReserveError"]],
│ │ │ │ │ +            ["impl UnwindSafe for FromVecWithNulError", 1, ["alloc::ffi::c_str::FromVecWithNulError"]],
│ │ │ │ │ +            ["impl UnwindSafe for IntoStringError", 1, ["alloc::ffi::c_str::IntoStringError"]],
│ │ │ │ │ +            ["impl UnwindSafe for NulError", 1, ["alloc::ffi::c_str::NulError"]],
│ │ │ │ │ +            ["impl UnwindSafe for CString", 1, ["alloc::ffi::c_str::CString"]],
│ │ │ │ │ +            ["impl UnwindSafe for FromUtf16Error", 1, ["alloc::string::FromUtf16Error"]],
│ │ │ │ │ +            ["impl UnwindSafe for FromUtf8Error", 1, ["alloc::string::FromUtf8Error"]],
│ │ │ │ │ +            ["impl UnwindSafe for String", 1, ["alloc::string::String"]],
│ │ │ │ │ +            ["impl<'a> UnwindSafe for Drain<'a>", 1, ["alloc::string::Drain"]],
│ │ │ │ │ +            ["impl<'a, B: ?Sized> UnwindSafe for Cow<'a, B>
      where\n    B: RefUnwindSafe,\n    <B as ToOwned>::Owned: UnwindSafe,
      ", 1, ["alloc::borrow::Cow"]],
│ │ │ │ │ +            ["impl<'a, I, A> UnwindSafe for Splice<'a, I, A>
      where\n    A: RefUnwindSafe,\n    I: UnwindSafe,\n    <I as Iterator>::Item: RefUnwindSafe,
      ", 1, ["alloc::vec::splice::Splice"]],
│ │ │ │ │ +            ["impl<'a, K, V> !UnwindSafe for IterMut<'a, K, V>", 1, ["alloc::collections::btree::map::IterMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> !UnwindSafe for RangeMut<'a, K, V>", 1, ["alloc::collections::btree::map::RangeMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> !UnwindSafe for ValuesMut<'a, K, V>", 1, ["alloc::collections::btree::map::ValuesMut"]],
│ │ │ │ │ +            ["impl<'a, K, V> UnwindSafe for Cursor<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Cursor"]],
│ │ │ │ │ +            ["impl<'a, K, V> UnwindSafe for Iter<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Iter"]],
│ │ │ │ │ +            ["impl<'a, K, V> UnwindSafe for Keys<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Keys"]],
│ │ │ │ │ +            ["impl<'a, K, V> UnwindSafe for Range<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Range"]],
│ │ │ │ │ +            ["impl<'a, K, V> UnwindSafe for Values<'a, K, V>
      where\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::Values"]],
│ │ │ │ │ +            ["impl<'a, K, V, A = Global> !UnwindSafe for Entry<'a, K, V, A>", 1, ["alloc::collections::btree::map::entry::Entry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A = Global> !UnwindSafe for CursorMut<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMut"]],
│ │ │ │ │ +            ["impl<'a, K, V, A = Global> !UnwindSafe for CursorMutKey<'a, K, V, A>", 1, ["alloc::collections::btree::map::CursorMutKey"]],
│ │ │ │ │ +            ["impl<'a, K, V, A = Global> !UnwindSafe for OccupiedEntry<'a, K, V, A>", 1, ["alloc::collections::btree::map::entry::OccupiedEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, A = Global> !UnwindSafe for OccupiedError<'a, K, V, A>", 1, ["alloc::collections::btree::map::entry::OccupiedError"]],
│ │ │ │ │ +            ["impl<'a, K, V, A = Global> !UnwindSafe for VacantEntry<'a, K, V, A>", 1, ["alloc::collections::btree::map::entry::VacantEntry"]],
│ │ │ │ │ +            ["impl<'a, K, V, F, A = Global> !UnwindSafe for ExtractIf<'a, K, V, F, A>", 1, ["alloc::collections::btree::map::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T> !UnwindSafe for IterMut<'a, T>", 1, ["alloc::collections::linked_list::IterMut"]],
│ │ │ │ │ +            ["impl<'a, T> !UnwindSafe for IterMut<'a, T>", 1, ["alloc::collections::vec_deque::iter_mut::IterMut"]],
│ │ │ │ │ +            ["impl<'a, T> UnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> UnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> UnwindSafe for Range<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Range"]],
│ │ │ │ │ +            ["impl<'a, T> UnwindSafe for SymmetricDifference<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::SymmetricDifference"]],
│ │ │ │ │ +            ["impl<'a, T> UnwindSafe for Union<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Union"]],
│ │ │ │ │ +            ["impl<'a, T> UnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::Iter"]],
│ │ │ │ │ +            ["impl<'a, T> UnwindSafe for Iter<'a, T>
      where\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::iter::Iter"]],
│ │ │ │ │ +            ["impl<'a, T, A = Global> !UnwindSafe for DrainSorted<'a, T, A>", 1, ["alloc::collections::binary_heap::DrainSorted"]],
│ │ │ │ │ +            ["impl<'a, T, A = Global> !UnwindSafe for PeekMut<'a, T, A>", 1, ["alloc::collections::binary_heap::PeekMut"]],
│ │ │ │ │ +            ["impl<'a, T, A = Global> !UnwindSafe for CursorMut<'a, T, A>", 1, ["alloc::collections::linked_list::CursorMut"]],
│ │ │ │ │ +            ["impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, A> UnwindSafe for Difference<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Difference"]],
│ │ │ │ │ +            ["impl<'a, T, A> UnwindSafe for Intersection<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::Intersection"]],
│ │ │ │ │ +            ["impl<'a, T, A> UnwindSafe for Cursor<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::Cursor"]],
│ │ │ │ │ +            ["impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::vec_deque::drain::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, A> UnwindSafe for Drain<'a, T, A>
      where\n    A: RefUnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::vec::drain::Drain"]],
│ │ │ │ │ +            ["impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>", 1, ["alloc::collections::btree::set::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>", 1, ["alloc::collections::linked_list::ExtractIf"]],
│ │ │ │ │ +            ["impl<'a, T, F, A = Global> !UnwindSafe for ExtractIf<'a, T, F, A>", 1, ["alloc::vec::extract_if::ExtractIf"]],
│ │ │ │ │ +            ["impl<K, V, A> UnwindSafe for BTreeMap<K, V, A>
      where\n    A: UnwindSafe + Allocator + Clone,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      "],
│ │ │ │ │ +            ["impl<K, V, A> UnwindSafe for IntoIter<K, V, A>
      where\n    A: UnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoIter"]],
│ │ │ │ │ +            ["impl<K, V, A> UnwindSafe for IntoKeys<K, V, A>
      where\n    A: UnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoKeys"]],
│ │ │ │ │ +            ["impl<K, V, A> UnwindSafe for IntoValues<K, V, A>
      where\n    A: UnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::map::IntoValues"]],
│ │ │ │ │ +            ["impl<T> !UnwindSafe for UniqueRc<T>", 1, ["alloc::rc::UniqueRc"]],
│ │ │ │ │ +            ["impl<T, A = Global> !UnwindSafe for Weak<T, A>", 1, ["alloc::rc::Weak"]],
│ │ │ │ │ +            ["impl<T, A> UnwindSafe for BinaryHeap<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::collections::binary_heap::BinaryHeap"]],
│ │ │ │ │ +            ["impl<T, A> UnwindSafe for IntoIter<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe + RefUnwindSafe,
      ", 1, ["alloc::collections::binary_heap::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> UnwindSafe for IntoIterSorted<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::collections::binary_heap::IntoIterSorted"]],
│ │ │ │ │ +            ["impl<T, A> UnwindSafe for BTreeSet<T, A>
      where\n    A: UnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::BTreeSet"]],
│ │ │ │ │ +            ["impl<T, A> UnwindSafe for IntoIter<T, A>
      where\n    A: UnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::collections::btree::set::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> UnwindSafe for IntoIter<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe + RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> UnwindSafe for LinkedList<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe + RefUnwindSafe,
      ", 1, ["alloc::collections::linked_list::LinkedList"]],
│ │ │ │ │ +            ["impl<T, A> UnwindSafe for IntoIter<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::collections::vec_deque::into_iter::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> UnwindSafe for VecDeque<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::collections::vec_deque::VecDeque"]],
│ │ │ │ │ +            ["impl<T, A> UnwindSafe for IntoIter<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe + RefUnwindSafe,
      ", 1, ["alloc::vec::into_iter::IntoIter"]],
│ │ │ │ │ +            ["impl<T, A> UnwindSafe for Vec<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::vec::Vec"]],
│ │ │ │ │ +            ["impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> UnwindSafe for Rc<T, A>"],
│ │ │ │ │ +            ["impl<T: RefUnwindSafe + ?Sized, A: Allocator + UnwindSafe> UnwindSafe for Arc<T, A>"],
│ │ │ │ │ +            ["impl<T: ?Sized> UnwindSafe for ThinBox<T>
      where\n    T: UnwindSafe,
      ", 1, ["alloc::boxed::thin::ThinBox"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> UnwindSafe for Box<T, A>
      where\n    A: UnwindSafe,\n    T: UnwindSafe,
      ", 1, ["alloc::boxed::Box"]],
│ │ │ │ │ +            ["impl<T: ?Sized, A> UnwindSafe for Weak<T, A>
      where\n    A: UnwindSafe,\n    T: RefUnwindSafe,
      ", 1, ["alloc::sync::Weak"]]
│ │ │ │ │          ],
│ │ │ │ │          "core": [],
│ │ │ │ │          "proc_macro": [
│ │ │ │ │              ["impl UnwindSafe for Delimiter", 1, ["proc_macro::Delimiter"]],
│ │ │ │ │              ["impl UnwindSafe for Level", 1, ["proc_macro::diagnostic::Level"]],
│ │ │ │ │              ["impl UnwindSafe for Spacing", 1, ["proc_macro::Spacing"]],
│ │ │ │ │              ["impl UnwindSafe for TokenTree", 1, ["proc_macro::TokenTree"]],
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/type.impl/alloc/alloc/struct.LayoutError.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,17 +1,17 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var type_impls = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["
      1.50.0 · source§
      impl Clone for LayoutError
      source§
      fn clone(&self) -> LayoutError
      Returns a copy of the value. Read more
      1.0.0 · source§
      fn clone_from(&mut self, source: &Self)
      Performs copy-assignment from source. Read more
      ", "Clone", "alloc::alloc::LayoutErr"],
│ │ │ │ │ -            ["
      1.50.0 · source§
      impl Debug for LayoutError
      source§
      fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
      Formats the value using the given formatter. Read more
      ", "Debug", "alloc::alloc::LayoutErr"],
│ │ │ │ │ -            ["
      source§
      impl Display for LayoutError
      source§
      fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
      Formats the value using the given formatter. Read more
      ", "Display", "alloc::alloc::LayoutErr"],
│ │ │ │ │ -            ["
      source§
      impl Error for LayoutError
      1.30.0 · source§
      fn source(&self) -> Option<&(dyn Error + 'static)>
      The lower-level source of this error, if any. Read more
      1.0.0 · source§
      fn description(&self) -> &str
      👎Deprecated since 1.42.0: use the Display impl or to_string()
       Read more
      1.0.0 · source§
      fn cause(&self) -> Option<&dyn Error>
      👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
      source§
      fn provide<'a>(&'a self, request: &mut Request<'a>)
      🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
      Provides type based access to context intended for error reports. Read more
      ", "Error", "alloc::alloc::LayoutErr"],
│ │ │ │ │ -            ["
      1.50.0 · source§
      impl PartialEq for LayoutError
      source§
      fn eq(&self, other: &LayoutError) -> bool
      This method tests for self and other values to be equal, and is used\nby ==.
      1.0.0 · source§
      fn ne(&self, other: &Rhs) -> bool
      This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
      ", "PartialEq", "alloc::alloc::LayoutErr"],
│ │ │ │ │ -            ["
      1.50.0 · source§
      impl Eq for LayoutError
      ", "Eq", "alloc::alloc::LayoutErr"],
│ │ │ │ │ -            ["
      1.50.0 · source§
      impl StructuralPartialEq for LayoutError
      ", "StructuralPartialEq", "alloc::alloc::LayoutErr"]
│ │ │ │ │ +            ["
      1.50.0 · source§
      impl Clone for LayoutError
      source§
      fn clone(&self) -> LayoutError
      Returns a copy of the value. Read more
      1.0.0 · source§
      fn clone_from(&mut self, source: &Self)
      Performs copy-assignment from source. Read more
      ", "Clone", "alloc::alloc::LayoutErr"],
│ │ │ │ │ +            ["
      1.50.0 · source§
      impl Debug for LayoutError
      source§
      fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
      Formats the value using the given formatter. Read more
      ", "Debug", "alloc::alloc::LayoutErr"],
│ │ │ │ │ +            ["
      source§
      impl Display for LayoutError
      source§
      fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
      Formats the value using the given formatter. Read more
      ", "Display", "alloc::alloc::LayoutErr"],
│ │ │ │ │ +            ["
      source§
      impl Error for LayoutError
      1.30.0 · source§
      fn source(&self) -> Option<&(dyn Error + 'static)>
      The lower-level source of this error, if any. Read more
      1.0.0 · source§
      fn description(&self) -> &str
      👎Deprecated since 1.42.0: use the Display impl or to_string()
       Read more
      1.0.0 · source§
      fn cause(&self) -> Option<&dyn Error>
      👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
      source§
      fn provide<'a>(&'a self, request: &mut Request<'a>)
      🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
      Provides type based access to context intended for error reports. Read more
      ", "Error", "alloc::alloc::LayoutErr"],
│ │ │ │ │ +            ["
      1.50.0 · source§
      impl PartialEq for LayoutError
      source§
      fn eq(&self, other: &LayoutError) -> bool
      This method tests for self and other values to be equal, and is used\nby ==.
      1.0.0 · source§
      fn ne(&self, other: &Rhs) -> bool
      This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
      ", "PartialEq", "alloc::alloc::LayoutErr"],
│ │ │ │ │ +            ["
      1.50.0 · source§
      impl Eq for LayoutError
      ", "Eq", "alloc::alloc::LayoutErr"],
│ │ │ │ │ +            ["
      1.50.0 · source§
      impl StructuralPartialEq for LayoutError
      ", "StructuralPartialEq", "alloc::alloc::LayoutErr"]
│ │ │ │ │          ]
│ │ │ │ │      };
│ │ │ │ │      if (window.register_type_impls) {
│ │ │ │ │          window.register_type_impls(type_impls);
│ │ │ │ │      } else {
│ │ │ │ │          window.pending_type_impls = type_impls;
│ │ │ │ │      }
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/type.impl/core/convert/enum.Infallible.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,21 +1,21 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var type_impls = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["
      1.34.0 · source§
      impl Clone for Infallible
      source§
      fn clone(&self) -> Infallible
      Returns a copy of the value. Read more
      1.0.0 · source§
      fn clone_from(&mut self, source: &Self)
      Performs copy-assignment from source. Read more
      ", "Clone", "alloc::string::ParseError"],
│ │ │ │ │ -            ["
      1.34.0 · source§
      impl Debug for Infallible
      source§
      fn fmt(&self, _: &mut Formatter<'_>) -> Result<(), Error>
      Formats the value using the given formatter. Read more
      ", "Debug", "alloc::string::ParseError"],
│ │ │ │ │ -            ["
      1.34.0 · source§
      impl Display for Infallible
      source§
      fn fmt(&self, _: &mut Formatter<'_>) -> Result<(), Error>
      Formats the value using the given formatter. Read more
      ", "Display", "alloc::string::ParseError"],
│ │ │ │ │ -            ["
      1.8.0 · source§
      impl Error for Infallible
      source§
      fn description(&self) -> &str
      👎Deprecated since 1.42.0: use the Display impl or to_string()
       Read more
      1.30.0 · source§
      fn source(&self) -> Option<&(dyn Error + 'static)>
      The lower-level source of this error, if any. Read more
      1.0.0 · source§
      fn cause(&self) -> Option<&dyn Error>
      👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
      source§
      fn provide<'a>(&'a self, request: &mut Request<'a>)
      🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
      Provides type based access to context intended for error reports. Read more
      ", "Error", "alloc::string::ParseError"],
│ │ │ │ │ -            ["
      1.34.0 · source§
      impl From<!> for Infallible
      source§
      fn from(x: !) -> Infallible
      Converts to this type from the input type.
      ", "From", "alloc::string::ParseError"],
│ │ │ │ │ -            ["
      1.44.0 · source§
      impl Hash for Infallible
      source§
      fn hash<H>(&self, _: &mut H)
      where\n    H: Hasher,
      Feeds this value into the given Hasher. Read more
      1.3.0 · source§
      fn hash_slice<H>(data: &[Self], state: &mut H)
      where\n    H: Hasher,\n    Self: Sized,
      Feeds a slice of this type into the given Hasher. Read more
      ", "Hash", "alloc::string::ParseError"],
│ │ │ │ │ -            ["
      1.34.0 · source§
      impl Ord for Infallible
      source§
      fn cmp(&self, _other: &Infallible) -> Ordering
      This method returns an Ordering between self and other. Read more
      1.21.0 · source§
      fn max(self, other: Self) -> Self
      where\n    Self: Sized,
      Compares and returns the maximum of two values. Read more
      1.21.0 · source§
      fn min(self, other: Self) -> Self
      where\n    Self: Sized,
      Compares and returns the minimum of two values. Read more
      1.50.0 · source§
      fn clamp(self, min: Self, max: Self) -> Self
      where\n    Self: Sized + PartialOrd,
      Restrict a value to a certain interval. Read more
      ", "Ord", "alloc::string::ParseError"],
│ │ │ │ │ -            ["
      1.34.0 · source§
      impl PartialEq for Infallible
      source§
      fn eq(&self, _: &Infallible) -> bool
      This method tests for self and other values to be equal, and is used\nby ==.
      1.0.0 · source§
      fn ne(&self, other: &Rhs) -> bool
      This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
      ", "PartialEq", "alloc::string::ParseError"],
│ │ │ │ │ -            ["
      1.34.0 · source§
      impl PartialOrd for Infallible
      source§
      fn partial_cmp(&self, _other: &Infallible) -> Option<Ordering>
      This method returns an ordering between self and other values if one exists. Read more
      1.0.0 · source§
      fn lt(&self, other: &Rhs) -> bool
      This method tests less than (for self and other) and is used by the < operator. Read more
      1.0.0 · source§
      fn le(&self, other: &Rhs) -> bool
      This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
      1.0.0 · source§
      fn gt(&self, other: &Rhs) -> bool
      This method tests greater than (for self and other) and is used by the > operator. Read more
      1.0.0 · source§
      fn ge(&self, other: &Rhs) -> bool
      This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
      ", "PartialOrd", "alloc::string::ParseError"],
│ │ │ │ │ -            ["
      1.34.0 · source§
      impl Copy for Infallible
      ", "Copy", "alloc::string::ParseError"],
│ │ │ │ │ -            ["
      1.34.0 · source§
      impl Eq for Infallible
      ", "Eq", "alloc::string::ParseError"]
│ │ │ │ │ +            ["
      1.34.0 · source§
      impl Clone for Infallible
      source§
      fn clone(&self) -> Infallible
      Returns a copy of the value. Read more
      1.0.0 · source§
      fn clone_from(&mut self, source: &Self)
      Performs copy-assignment from source. Read more
      ", "Clone", "alloc::string::ParseError"],
│ │ │ │ │ +            ["
      1.34.0 · source§
      impl Debug for Infallible
      source§
      fn fmt(&self, _: &mut Formatter<'_>) -> Result<(), Error>
      Formats the value using the given formatter. Read more
      ", "Debug", "alloc::string::ParseError"],
│ │ │ │ │ +            ["
      1.34.0 · source§
      impl Display for Infallible
      source§
      fn fmt(&self, _: &mut Formatter<'_>) -> Result<(), Error>
      Formats the value using the given formatter. Read more
      ", "Display", "alloc::string::ParseError"],
│ │ │ │ │ +            ["
      1.8.0 · source§
      impl Error for Infallible
      source§
      fn description(&self) -> &str
      👎Deprecated since 1.42.0: use the Display impl or to_string()
       Read more
      1.30.0 · source§
      fn source(&self) -> Option<&(dyn Error + 'static)>
      The lower-level source of this error, if any. Read more
      1.0.0 · source§
      fn cause(&self) -> Option<&dyn Error>
      👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
      source§
      fn provide<'a>(&'a self, request: &mut Request<'a>)
      🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
      Provides type based access to context intended for error reports. Read more
      ", "Error", "alloc::string::ParseError"],
│ │ │ │ │ +            ["
      1.34.0 · source§
      impl From<!> for Infallible
      source§
      fn from(x: !) -> Infallible
      Converts to this type from the input type.
      ", "From", "alloc::string::ParseError"],
│ │ │ │ │ +            ["
      1.44.0 · source§
      impl Hash for Infallible
      source§
      fn hash<H>(&self, _: &mut H)
      where\n    H: Hasher,
      Feeds this value into the given Hasher. Read more
      1.3.0 · source§
      fn hash_slice<H>(data: &[Self], state: &mut H)
      where\n    H: Hasher,\n    Self: Sized,
      Feeds a slice of this type into the given Hasher. Read more
      ", "Hash", "alloc::string::ParseError"],
│ │ │ │ │ +            ["
      1.34.0 · source§
      impl Ord for Infallible
      source§
      fn cmp(&self, _other: &Infallible) -> Ordering
      This method returns an Ordering between self and other. Read more
      1.21.0 · source§
      fn max(self, other: Self) -> Self
      where\n    Self: Sized,
      Compares and returns the maximum of two values. Read more
      1.21.0 · source§
      fn min(self, other: Self) -> Self
      where\n    Self: Sized,
      Compares and returns the minimum of two values. Read more
      1.50.0 · source§
      fn clamp(self, min: Self, max: Self) -> Self
      where\n    Self: Sized + PartialOrd,
      Restrict a value to a certain interval. Read more
      ", "Ord", "alloc::string::ParseError"],
│ │ │ │ │ +            ["
      1.34.0 · source§
      impl PartialEq for Infallible
      source§
      fn eq(&self, _: &Infallible) -> bool
      This method tests for self and other values to be equal, and is used\nby ==.
      1.0.0 · source§
      fn ne(&self, other: &Rhs) -> bool
      This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
      ", "PartialEq", "alloc::string::ParseError"],
│ │ │ │ │ +            ["
      1.34.0 · source§
      impl PartialOrd for Infallible
      source§
      fn partial_cmp(&self, _other: &Infallible) -> Option<Ordering>
      This method returns an ordering between self and other values if one exists. Read more
      1.0.0 · source§
      fn lt(&self, other: &Rhs) -> bool
      This method tests less than (for self and other) and is used by the < operator. Read more
      1.0.0 · source§
      fn le(&self, other: &Rhs) -> bool
      This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
      1.0.0 · source§
      fn gt(&self, other: &Rhs) -> bool
      This method tests greater than (for self and other) and is used by the > operator. Read more
      1.0.0 · source§
      fn ge(&self, other: &Rhs) -> bool
      This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
      ", "PartialOrd", "alloc::string::ParseError"],
│ │ │ │ │ +            ["
      1.34.0 · source§
      impl Copy for Infallible
      ", "Copy", "alloc::string::ParseError"],
│ │ │ │ │ +            ["
      1.34.0 · source§
      impl Eq for Infallible
      ", "Eq", "alloc::string::ParseError"]
│ │ │ │ │          ]
│ │ │ │ │      };
│ │ │ │ │      if (window.register_type_impls) {
│ │ │ │ │          window.register_type_impls(type_impls);
│ │ │ │ │      } else {
│ │ │ │ │          window.pending_type_impls = type_impls;
│ │ │ │ │      }
│ │ │ ├── ./usr/share/doc/rust-web-doc/html/type.impl/core/result/enum.Result.js
│ │ │ │ ├── js-beautify {}
│ │ │ │ │ @@ -1,27 +1,27 @@
│ │ │ │ │  (function() {
│ │ │ │ │      var type_impls = {
│ │ │ │ │          "alloc": [
│ │ │ │ │ -            ["
      source§
      impl<T, E> Clone for Result<T, E>
      where\n    T: Clone,\n    E: Clone,
      source§
      fn clone(&self) -> Result<T, E>
      Returns a copy of the value. Read more
      source§
      fn clone_from(&mut self, source: &Result<T, E>)
      Performs copy-assignment from source. Read more
      ", "Clone", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E> Debug for Result<T, E>
      where\n    T: Debug,\n    E: Debug,
      source§
      fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
      Formats the value using the given formatter. Read more
      ", "Debug", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>
      where\n    V: FromIterator<A>,
      source§
      fn from_iter<I>(iter: I) -> Result<V, E>
      where\n    I: IntoIterator<Item = Result<A, E>>,
      Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err occur, a\ncontainer with the values of each Result is returned.
      \n
      Here is an example which increments every integer in a vector,\nchecking for overflow:
      \n\n
      let v = vec![1, 2];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_add(1).ok_or(\"Overflow!\")\n).collect();\nassert_eq!(res, Ok(vec![2, 3]));
      Run
      \n
      Here is another example that tries to subtract one from another list\nof integers, this time checking for underflow:
      \n\n
      let v = vec![1, 2, 0];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_sub(1).ok_or(\"Underflow!\")\n).collect();\nassert_eq!(res, Err(\"Underflow!\"));
      Run
      \n
      Here is a variation on the previous example, showing that no\nfurther elements are taken from iter after the first Err.
      \n\n
      let v = vec![3, 2, 1, 10];\nlet mut shared = 0;\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {\n    shared += x;\n    x.checked_sub(2).ok_or(\"Underflow!\")\n}).collect();\nassert_eq!(res, Err(\"Underflow!\"));\nassert_eq!(shared, 6);
      Run
      \n
      Since the third element caused an underflow, no further elements were taken,\nso the final value of shared is 6 (= 3 + 2 + 1), not 16.
      \n
      ", "FromIterator>", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E, F> FromResidual<Result<Infallible, E>> for Result<T, F>
      where\n    F: From<E>,
      source§
      fn from_residual(residual: Result<Infallible, E>) -> Result<T, F>
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      Constructs the type from a compatible Residual type. Read more
      ", "FromResidual>", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E, F> FromResidual<Yeet<E>> for Result<T, F>
      where\n    F: From<E>,
      source§
      fn from_residual(_: Yeet<E>) -> Result<T, F>
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      Constructs the type from a compatible Residual type. Read more
      ", "FromResidual>", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E> Hash for Result<T, E>
      where\n    T: Hash,\n    E: Hash,
      source§
      fn hash<__H>(&self, state: &mut __H)
      where\n    __H: Hasher,
      Feeds this value into the given Hasher. Read more
      1.3.0 · source§
      fn hash_slice<H>(data: &[Self], state: &mut H)
      where\n    H: Hasher,\n    Self: Sized,
      Feeds a slice of this type into the given Hasher. Read more
      ", "Hash", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E> IntoIterator for Result<T, E>
      source§
      fn into_iter(self) -> IntoIter<T>
      Returns a consuming iterator over the possibly contained value.
      \n
      The iterator yields one value if the result is Result::Ok, otherwise none.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(5);\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, [5]);\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, []);
      Run
      \n
      §
      type Item = T
      The type of the elements being iterated over.
      §
      type IntoIter = IntoIter<T>
      Which kind of iterator are we turning this into?
      ", "IntoIterator", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E> Ord for Result<T, E>
      where\n    T: Ord,\n    E: Ord,
      source§
      fn cmp(&self, other: &Result<T, E>) -> Ordering
      This method returns an Ordering between self and other. Read more
      1.21.0 · source§
      fn max(self, other: Self) -> Self
      where\n    Self: Sized,
      Compares and returns the maximum of two values. Read more
      1.21.0 · source§
      fn min(self, other: Self) -> Self
      where\n    Self: Sized,
      Compares and returns the minimum of two values. Read more
      1.50.0 · source§
      fn clamp(self, min: Self, max: Self) -> Self
      where\n    Self: Sized + PartialOrd,
      Restrict a value to a certain interval. Read more
      ", "Ord", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E> PartialEq for Result<T, E>
      where\n    T: PartialEq,\n    E: PartialEq,
      source§
      fn eq(&self, other: &Result<T, E>) -> bool
      This method tests for self and other values to be equal, and is used\nby ==.
      source§
      fn ne(&self, other: &Rhs) -> bool
      This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
      ", "PartialEq", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E> PartialOrd for Result<T, E>
      where\n    T: PartialOrd,\n    E: PartialOrd,
      source§
      fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>
      This method returns an ordering between self and other values if one exists. Read more
      source§
      fn lt(&self, other: &Rhs) -> bool
      This method tests less than (for self and other) and is used by the < operator. Read more
      source§
      fn le(&self, other: &Rhs) -> bool
      This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
      source§
      fn gt(&self, other: &Rhs) -> bool
      This method tests greater than (for self and other) and is used by the > operator. Read more
      source§
      fn ge(&self, other: &Rhs) -> bool
      This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
      ", "PartialOrd", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      1.16.0 · source§
      impl<T, U, E> Product<Result<U, E>> for Result<T, E>
      where\n    T: Product<U>,
      source§
      fn product<I>(iter: I) -> Result<T, E>
      where\n    I: Iterator<Item = Result<U, E>>,
      Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the product of all elements is returned.
      \n
      §Examples
      \n
      This multiplies each number in a vector of strings,\nif a string could not be parsed the operation returns Err:
      \n\n
      let nums = vec![\"5\", \"10\", \"1\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert_eq!(total, Ok(100));\nlet nums = vec![\"5\", \"10\", \"one\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert!(total.is_err());
      Run
      \n
      ", "Product>", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E> Result<T, E>
      const: 1.48.0 · source
      pub const fn is_ok(&self) -> bool
      Returns true if the result is Ok.
      \n
      §Examples
      \n
      let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_ok(), true);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_ok(), false);
      Run
      \n
      1.70.0 · source
      pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool
      Returns true if the result is Ok and the value inside of it matches a predicate.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.is_ok_and(|x| x > 1), true);\n\nlet x: Result<u32, &str> = Ok(0);\nassert_eq!(x.is_ok_and(|x| x > 1), false);\n\nlet x: Result<u32, &str> = Err(\"hey\");\nassert_eq!(x.is_ok_and(|x| x > 1), false);
      Run
      \n
      const: 1.48.0 · source
      pub const fn is_err(&self) -> bool
      Returns true if the result is Err.
      \n
      §Examples
      \n
      let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_err(), false);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_err(), true);
      Run
      \n
      1.70.0 · source
      pub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool
      Returns true if the result is Err and the value inside of it matches a predicate.
      \n
      §Examples
      \n
      use std::io::{Error, ErrorKind};\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);\n\nlet x: Result<u32, Error> = Ok(123);\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
      Run
      \n
      source
      pub fn ok(self) -> Option<T>
      Converts from Result<T, E> to Option<T>.
      \n
      Converts self into an Option<T>, consuming self,\nand discarding the error, if any.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.ok(), Some(2));\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.ok(), None);
      Run
      \n
      source
      pub fn err(self) -> Option<E>
      Converts from Result<T, E> to Option<E>.
      \n
      Converts self into an Option<E>, consuming self,\nand discarding the success value, if any.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.err(), None);\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.err(), Some(\"Nothing here\"));
      Run
      \n
      const: 1.48.0 · source
      pub const fn as_ref(&self) -> Result<&T, &E>
      Converts from &Result<T, E> to Result<&T, &E>.
      \n
      Produces a new Result, containing a reference\ninto the original, leaving the original in place.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.as_ref(), Ok(&2));\n\nlet x: Result<u32, &str> = Err(\"Error\");\nassert_eq!(x.as_ref(), Err(&\"Error\"));
      Run
      \n
      const: unstable · source
      pub fn as_mut(&mut self) -> Result<&mut T, &mut E>
      Converts from &mut Result<T, E> to Result<&mut T, &mut E>.
      \n
      §Examples
      \n
      fn mutate(r: &mut Result<i32, i32>) {\n    match r.as_mut() {\n        Ok(v) => *v = 42,\n        Err(e) => *e = 0,\n    }\n}\n\nlet mut x: Result<i32, i32> = Ok(2);\nmutate(&mut x);\nassert_eq!(x.unwrap(), 42);\n\nlet mut x: Result<i32, i32> = Err(13);\nmutate(&mut x);\nassert_eq!(x.unwrap_err(), 0);
      Run
      \n
      source
      pub fn map<U, F>(self, op: F) -> Result<U, E>
      where\n    F: FnOnce(T) -> U,
      Maps a Result<T, E> to Result<U, E> by applying a function to a\ncontained Ok value, leaving an Err value untouched.
      \n
      This function can be used to compose the results of two functions.
      \n
      §Examples
      \n
      Print the numbers on each line of a string multiplied by two.
      \n\n
      let line = \"1\\n2\\n3\\n4\\n\";\n\nfor num in line.lines() {\n    match num.parse::<i32>().map(|i| i * 2) {\n        Ok(n) => println!(\"{n}\"),\n        Err(..) => {}\n    }\n}
      Run
      \n
      1.41.0 · source
      pub fn map_or<U, F>(self, default: U, f: F) -> U
      where\n    F: FnOnce(T) -> U,
      Returns the provided default (if Err), or\napplies a function to the contained value (if Ok).
      \n
      Arguments passed to map_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use map_or_else,\nwhich is lazily evaluated.
      \n
      §Examples
      \n
      let x: Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or(42, |v| v.len()), 3);\n\nlet x: Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or(42, |v| v.len()), 42);
      Run
      \n
      1.41.0 · source
      pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
      where\n    D: FnOnce(E) -> U,\n    F: FnOnce(T) -> U,
      Maps a Result<T, E> to U by applying fallback function default to\na contained Err value, or function f to a contained Ok value.
      \n
      This function can be used to unpack a successful result\nwhile handling an error.
      \n
      §Examples
      \n
      let k = 21;\n\nlet x : Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);\n\nlet x : Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);
      Run
      \n
      source
      pub fn map_err<F, O>(self, op: O) -> Result<T, F>
      where\n    O: FnOnce(E) -> F,
      Maps a Result<T, E> to Result<T, F> by applying a function to a\ncontained Err value, leaving an Ok value untouched.
      \n
      This function can be used to pass through a successful result while handling\nan error.
      \n
      §Examples
      \n
      fn stringify(x: u32) -> String { format!(\"error code: {x}\") }\n\nlet x: Result<u32, u32> = Ok(2);\nassert_eq!(x.map_err(stringify), Ok(2));\n\nlet x: Result<u32, u32> = Err(13);\nassert_eq!(x.map_err(stringify), Err(\"error code: 13\".to_string()));
      Run
      \n
      1.76.0 · source
      pub fn inspect<F>(self, f: F) -> Result<T, E>
      where\n    F: FnOnce(&T),
      Calls a function with a reference to the contained value if Ok.
      \n
      Returns the original result.
      \n
      §Examples
      \n
      let x: u8 = \"4\"\n    .parse::<u8>()\n    .inspect(|x| println!(\"original: {x}\"))\n    .map(|x| x.pow(3))\n    .expect(\"failed to parse number\");
      Run
      \n
      1.76.0 · source
      pub fn inspect_err<F>(self, f: F) -> Result<T, E>
      where\n    F: FnOnce(&E),
      Calls a function with a reference to the contained value if Err.
      \n
      Returns the original result.
      \n
      §Examples
      \n
      use std::{fs, io};\n\nfn read() -> io::Result<String> {\n    fs::read_to_string(\"address.txt\")\n        .inspect_err(|e| eprintln!(\"failed to read file: {e}\"))\n}
      Run
      \n
      1.47.0 · source
      pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>
      where\n    T: Deref,
      Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.
      \n
      Coerces the Ok variant of the original Result via Deref\nand returns the new Result.
      \n
      §Examples
      \n
      let x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&str, &u32> = Ok(\"hello\");\nassert_eq!(x.as_deref(), y);\n\nlet x: Result<String, u32> = Err(42);\nlet y: Result<&str, &u32> = Err(&42);\nassert_eq!(x.as_deref(), y);
      Run
      \n
      1.47.0 · source
      pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>
      where\n    T: DerefMut,
      Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.
      \n
      Coerces the Ok variant of the original Result via DerefMut\nand returns the new Result.
      \n
      §Examples
      \n
      let mut s = \"HELLO\".to_string();\nlet mut x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&mut str, &mut u32> = Ok(&mut s);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);\n\nlet mut i = 42;\nlet mut x: Result<String, u32> = Err(42);\nlet y: Result<&mut str, &mut u32> = Err(&mut i);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
      Run
      \n
      source
      pub fn iter(&self) -> Iter<'_, T>
      Returns an iterator over the possibly contained value.
      \n
      The iterator yields one value if the result is Result::Ok, otherwise none.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(7);\nassert_eq!(x.iter().next(), Some(&7));\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter().next(), None);
      Run
      \n
      source
      pub fn iter_mut(&mut self) -> IterMut<'_, T>
      Returns a mutable iterator over the possibly contained value.
      \n
      The iterator yields one value if the result is Result::Ok, otherwise none.
      \n
      §Examples
      \n
      let mut x: Result<u32, &str> = Ok(7);\nmatch x.iter_mut().next() {\n    Some(v) => *v = 40,\n    None => {},\n}\nassert_eq!(x, Ok(40));\n\nlet mut x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter_mut().next(), None);
      Run
      \n
      1.4.0 · source
      pub fn expect(self, msg: &str) -> T
      where\n    E: Debug,
      Returns the contained Ok value, consuming the self value.
      \n
      Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.
      \n
      §Panics
      \n
      Panics if the value is an Err, with a panic message including the\npassed message, and the content of the Err.
      \n
      §Examples
      \n
      ⓘ
      let x: Result<u32, &str> = Err(\"emergency failure\");\nx.expect(\"Testing expect\"); // panics with `Testing expect: emergency failure`
      Run
      \n
      §Recommended Message Style
      \n
      We recommend that expect messages are used to describe the reason you\nexpect the Result should be Ok.
      \n\n
      ⓘ
      let path = std::env::var(\"IMPORTANT_PATH\")\n    .expect(\"env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`\");
      Run
      \n
      Hint: If you’re having trouble remembering how to phrase expect\nerror messages remember to focus on the word “should” as in “env\nvariable should be set by blah” or “the given binary should be available\nand executable by the current user”.
      \n
      For more detail on expect message styles and the reasoning behind our recommendation please\nrefer to the section on “Common Message\nStyles” in the\nstd::error module docs.
      \n
      source
      pub fn unwrap(self) -> T
      where\n    E: Debug,
      Returns the contained Ok value, consuming the self value.
      \n
      Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.
      \n
      §Panics
      \n
      Panics if the value is an Err, with a panic message provided by the\nErr’s value.
      \n
      §Examples
      \n
      Basic usage:
      \n\n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.unwrap(), 2);
      Run
      \n\n
      ⓘ
      let x: Result<u32, &str> = Err(\"emergency failure\");\nx.unwrap(); // panics with `emergency failure`
      Run
      \n
      1.16.0 · source
      pub fn unwrap_or_default(self) -> T
      where\n    T: Default,
      Returns the contained Ok value or a default
      \n
      Consumes the self argument then, if Ok, returns the contained\nvalue, otherwise if Err, returns the default value for that\ntype.
      \n
      §Examples
      \n
      Converts a string to an integer, turning poorly-formed strings\ninto 0 (the default value for integers). parse converts\na string to any other type that implements FromStr, returning an\nErr on error.
      \n\n
      let good_year_from_input = \"1909\";\nlet bad_year_from_input = \"190blarg\";\nlet good_year = good_year_from_input.parse().unwrap_or_default();\nlet bad_year = bad_year_from_input.parse().unwrap_or_default();\n\nassert_eq!(1909, good_year);\nassert_eq!(0, bad_year);
      Run
      \n
      1.17.0 · source
      pub fn expect_err(self, msg: &str) -> E
      where\n    T: Debug,
      Returns the contained Err value, consuming the self value.
      \n
      §Panics
      \n
      Panics if the value is an Ok, with a panic message including the\npassed message, and the content of the Ok.
      \n
      §Examples
      \n
      ⓘ
      let x: Result<u32, &str> = Ok(10);\nx.expect_err(\"Testing expect_err\"); // panics with `Testing expect_err: 10`
      Run
      \n
      source
      pub fn unwrap_err(self) -> E
      where\n    T: Debug,
      Returns the contained Err value, consuming the self value.
      \n
      §Panics
      \n
      Panics if the value is an Ok, with a custom panic message provided\nby the Ok’s value.
      \n
      §Examples
      \n
      ⓘ
      let x: Result<u32, &str> = Ok(2);\nx.unwrap_err(); // panics with `2`
      Run
      \n\n
      let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(x.unwrap_err(), \"emergency failure\");
      Run
      \n
      source
      pub fn into_ok(self) -> T
      where\n    E: Into<!>,
      🔬This is a nightly-only experimental API. (unwrap_infallible #61695)
      Returns the contained Ok value, but never panics.
      \n
      Unlike unwrap, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap as a maintainability safeguard that will fail\nto compile if the error type of the Result is later changed\nto an error that can actually occur.
      \n
      §Examples
      \n
      \nfn only_good_news() -> Result<String, !> {\n    Ok(\"this is fine\".into())\n}\n\nlet s: String = only_good_news().into_ok();\nprintln!(\"{s}\");
      Run
      \n
      source
      pub fn into_err(self) -> E
      where\n    T: Into<!>,
      🔬This is a nightly-only experimental API. (unwrap_infallible #61695)
      Returns the contained Err value, but never panics.
      \n
      Unlike unwrap_err, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap_err as a maintainability safeguard that will fail\nto compile if the ok type of the Result is later changed\nto a type that can actually occur.
      \n
      §Examples
      \n
      \nfn only_bad_news() -> Result<!, String> {\n    Err(\"Oops, it failed\".into())\n}\n\nlet error: String = only_bad_news().into_err();\nprintln!(\"{error}\");
      Run
      \n
      source
      pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>
      Returns res if the result is Ok, otherwise returns the Err value of self.
      \n
      Arguments passed to and are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use and_then, which is\nlazily evaluated.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<&str, &str> = Ok(\"foo\");\nassert_eq!(x.and(y), Err(\"early error\"));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"not a 2\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Ok(\"different result type\");\nassert_eq!(x.and(y), Ok(\"different result type\"));
      Run
      \n
      source
      pub fn and_then<U, F>(self, op: F) -> Result<U, E>
      where\n    F: FnOnce(T) -> Result<U, E>,
      Calls op if the result is Ok, otherwise returns the Err value of self.
      \n
      This function can be used for control flow based on Result values.
      \n
      §Examples
      \n
      fn sq_then_to_string(x: u32) -> Result<String, &'static str> {\n    x.checked_mul(x).map(|sq| sq.to_string()).ok_or(\"overflowed\")\n}\n\nassert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));\nassert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err(\"overflowed\"));\nassert_eq!(Err(\"not a number\").and_then(sq_then_to_string), Err(\"not a number\"));
      Run
      \n
      Often used to chain fallible operations that may return Err.
      \n\n
      use std::{io::ErrorKind, path::Path};\n\n// Note: on Windows \"/\" maps to \"C:\\\"\nlet root_modified_time = Path::new(\"/\").metadata().and_then(|md| md.modified());\nassert!(root_modified_time.is_ok());\n\nlet should_fail = Path::new(\"/bad/path\").metadata().and_then(|md| md.modified());\nassert!(should_fail.is_err());\nassert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
      Run
      \n
      source
      pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>
      Returns res if the result is Err, otherwise returns the Ok value of self.
      \n
      Arguments passed to or are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use or_else, which is\nlazily evaluated.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<u32, &str> = Ok(2);\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Ok(100);\nassert_eq!(x.or(y), Ok(2));
      Run
      \n
      source
      pub fn or_else<F, O>(self, op: O) -> Result<T, F>
      where\n    O: FnOnce(E) -> Result<T, F>,
      Calls op if the result is Err, otherwise returns the Ok value of self.
      \n
      This function can be used for control flow based on result values.
      \n
      §Examples
      \n
      fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }\nfn err(x: u32) -> Result<u32, u32> { Err(x) }\n\nassert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));\nassert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));\nassert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));\nassert_eq!(Err(3).or_else(err).or_else(err), Err(3));
      Run
      \n
      source
      pub fn unwrap_or(self, default: T) -> T
      Returns the contained Ok value or a provided default.
      \n
      Arguments passed to unwrap_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use unwrap_or_else,\nwhich is lazily evaluated.
      \n
      §Examples
      \n
      let default = 2;\nlet x: Result<u32, &str> = Ok(9);\nassert_eq!(x.unwrap_or(default), 9);\n\nlet x: Result<u32, &str> = Err(\"error\");\nassert_eq!(x.unwrap_or(default), default);
      Run
      \n
      source
      pub fn unwrap_or_else<F>(self, op: F) -> T
      where\n    F: FnOnce(E) -> T,
      Returns the contained Ok value or computes it from a closure.
      \n
      §Examples
      \n
      fn count(x: &str) -> usize { x.len() }\n\nassert_eq!(Ok(2).unwrap_or_else(count), 2);\nassert_eq!(Err(\"foo\").unwrap_or_else(count), 3);
      Run
      \n
      1.58.0 · source
      pub unsafe fn unwrap_unchecked(self) -> T
      Returns the contained Ok value, consuming the self value,\nwithout checking that the value is not an Err.
      \n
      §Safety
      \n
      Calling this method on an Err is undefined behavior.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(unsafe { x.unwrap_unchecked() }, 2);
      Run
      \n\n
      let x: Result<u32, &str> = Err(\"emergency failure\");\nunsafe { x.unwrap_unchecked(); } // Undefined behavior!
      Run
      \n
      1.58.0 · source
      pub unsafe fn unwrap_err_unchecked(self) -> E
      Returns the contained Err value, consuming the self value,\nwithout checking that the value is not an Ok.
      \n
      §Safety
      \n
      Calling this method on an Ok is undefined behavior.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nunsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
      Run
      \n\n
      let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(unsafe { x.unwrap_err_unchecked() }, \"emergency failure\");
      Run
      \n
      ", 0, "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      1.16.0 · source§
      impl<T, U, E> Sum<Result<U, E>> for Result<T, E>
      where\n    T: Sum<U>,
      source§
      fn sum<I>(iter: I) -> Result<T, E>
      where\n    I: Iterator<Item = Result<U, E>>,
      Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the sum of all elements is returned.
      \n
      §Examples
      \n
      This sums up every integer in a vector, rejecting the sum if a negative\nelement is encountered:
      \n\n
      let f = |&x: &i32| if x < 0 { Err(\"Negative element found\") } else { Ok(x) };\nlet v = vec![1, 2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Ok(3));\nlet v = vec![1, -2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Err(\"Negative element found\"));
      Run
      \n
      ", "Sum>", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E> Try for Result<T, E>
      §
      type Output = T
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      The type of the value produced by ? when not short-circuiting.
      §
      type Residual = Result<Infallible, E>
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      The type of the value passed to FromResidual::from_residual\nas part of ? when short-circuiting. Read more
      source§
      fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      Constructs the type from its Output type. Read more
      source§
      fn branch(\n    self\n) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      Used in ? to decide whether the operator should produce a value\n(because this returned ControlFlow::Continue)\nor propagate a value back to the caller\n(because this returned ControlFlow::Break). Read more
      ", "Try", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E> Copy for Result<T, E>
      where\n    T: Copy,\n    E: Copy,
      ", "Copy", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E> Eq for Result<T, E>
      where\n    T: Eq,\n    E: Eq,
      ", "Eq", "alloc::fmt::Result"],
│ │ │ │ │ -            ["
      source§
      impl<T, E> StructuralPartialEq for Result<T, E>
      ", "StructuralPartialEq", "alloc::fmt::Result"]
│ │ │ │ │ +            ["
      source§
      impl<T, E> Clone for Result<T, E>
      where\n    T: Clone,\n    E: Clone,
      source§
      fn clone(&self) -> Result<T, E>
      Returns a copy of the value. Read more
      source§
      fn clone_from(&mut self, source: &Result<T, E>)
      Performs copy-assignment from source. Read more
      ", "Clone", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E> Debug for Result<T, E>
      where\n    T: Debug,\n    E: Debug,
      source§
      fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
      Formats the value using the given formatter. Read more
      ", "Debug", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>
      where\n    V: FromIterator<A>,
      source§
      fn from_iter<I>(iter: I) -> Result<V, E>
      where\n    I: IntoIterator<Item = Result<A, E>>,
      Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err occur, a\ncontainer with the values of each Result is returned.
      \n
      Here is an example which increments every integer in a vector,\nchecking for overflow:
      \n\n
      let v = vec![1, 2];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_add(1).ok_or(\"Overflow!\")\n).collect();\nassert_eq!(res, Ok(vec![2, 3]));
      Run
      \n
      Here is another example that tries to subtract one from another list\nof integers, this time checking for underflow:
      \n\n
      let v = vec![1, 2, 0];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_sub(1).ok_or(\"Underflow!\")\n).collect();\nassert_eq!(res, Err(\"Underflow!\"));
      Run
      \n
      Here is a variation on the previous example, showing that no\nfurther elements are taken from iter after the first Err.
      \n\n
      let v = vec![3, 2, 1, 10];\nlet mut shared = 0;\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {\n    shared += x;\n    x.checked_sub(2).ok_or(\"Underflow!\")\n}).collect();\nassert_eq!(res, Err(\"Underflow!\"));\nassert_eq!(shared, 6);
      Run
      \n
      Since the third element caused an underflow, no further elements were taken,\nso the final value of shared is 6 (= 3 + 2 + 1), not 16.
      \n
      ", "FromIterator>", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E, F> FromResidual<Result<Infallible, E>> for Result<T, F>
      where\n    F: From<E>,
      source§
      fn from_residual(residual: Result<Infallible, E>) -> Result<T, F>
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      Constructs the type from a compatible Residual type. Read more
      ", "FromResidual>", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E, F> FromResidual<Yeet<E>> for Result<T, F>
      where\n    F: From<E>,
      source§
      fn from_residual(_: Yeet<E>) -> Result<T, F>
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      Constructs the type from a compatible Residual type. Read more
      ", "FromResidual>", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E> Hash for Result<T, E>
      where\n    T: Hash,\n    E: Hash,
      source§
      fn hash<__H>(&self, state: &mut __H)
      where\n    __H: Hasher,
      Feeds this value into the given Hasher. Read more
      1.3.0 · source§
      fn hash_slice<H>(data: &[Self], state: &mut H)
      where\n    H: Hasher,\n    Self: Sized,
      Feeds a slice of this type into the given Hasher. Read more
      ", "Hash", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E> IntoIterator for Result<T, E>
      source§
      fn into_iter(self) -> IntoIter<T>
      Returns a consuming iterator over the possibly contained value.
      \n
      The iterator yields one value if the result is Result::Ok, otherwise none.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(5);\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, [5]);\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, []);
      Run
      \n
      §
      type Item = T
      The type of the elements being iterated over.
      §
      type IntoIter = IntoIter<T>
      Which kind of iterator are we turning this into?
      ", "IntoIterator", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E> Ord for Result<T, E>
      where\n    T: Ord,\n    E: Ord,
      source§
      fn cmp(&self, other: &Result<T, E>) -> Ordering
      This method returns an Ordering between self and other. Read more
      1.21.0 · source§
      fn max(self, other: Self) -> Self
      where\n    Self: Sized,
      Compares and returns the maximum of two values. Read more
      1.21.0 · source§
      fn min(self, other: Self) -> Self
      where\n    Self: Sized,
      Compares and returns the minimum of two values. Read more
      1.50.0 · source§
      fn clamp(self, min: Self, max: Self) -> Self
      where\n    Self: Sized + PartialOrd,
      Restrict a value to a certain interval. Read more
      ", "Ord", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E> PartialEq for Result<T, E>
      where\n    T: PartialEq,\n    E: PartialEq,
      source§
      fn eq(&self, other: &Result<T, E>) -> bool
      This method tests for self and other values to be equal, and is used\nby ==.
      source§
      fn ne(&self, other: &Rhs) -> bool
      This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
      ", "PartialEq", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E> PartialOrd for Result<T, E>
      where\n    T: PartialOrd,\n    E: PartialOrd,
      source§
      fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>
      This method returns an ordering between self and other values if one exists. Read more
      source§
      fn lt(&self, other: &Rhs) -> bool
      This method tests less than (for self and other) and is used by the < operator. Read more
      source§
      fn le(&self, other: &Rhs) -> bool
      This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
      source§
      fn gt(&self, other: &Rhs) -> bool
      This method tests greater than (for self and other) and is used by the > operator. Read more
      source§
      fn ge(&self, other: &Rhs) -> bool
      This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
      ", "PartialOrd", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      1.16.0 · source§
      impl<T, U, E> Product<Result<U, E>> for Result<T, E>
      where\n    T: Product<U>,
      source§
      fn product<I>(iter: I) -> Result<T, E>
      where\n    I: Iterator<Item = Result<U, E>>,
      Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the product of all elements is returned.
      \n
      §Examples
      \n
      This multiplies each number in a vector of strings,\nif a string could not be parsed the operation returns Err:
      \n\n
      let nums = vec![\"5\", \"10\", \"1\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert_eq!(total, Ok(100));\nlet nums = vec![\"5\", \"10\", \"one\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert!(total.is_err());
      Run
      \n
      ", "Product>", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E> Result<T, E>
      const: 1.48.0 · source
      pub const fn is_ok(&self) -> bool
      Returns true if the result is Ok.
      \n
      §Examples
      \n
      let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_ok(), true);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_ok(), false);
      Run
      \n
      1.70.0 · source
      pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool
      Returns true if the result is Ok and the value inside of it matches a predicate.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.is_ok_and(|x| x > 1), true);\n\nlet x: Result<u32, &str> = Ok(0);\nassert_eq!(x.is_ok_and(|x| x > 1), false);\n\nlet x: Result<u32, &str> = Err(\"hey\");\nassert_eq!(x.is_ok_and(|x| x > 1), false);
      Run
      \n
      const: 1.48.0 · source
      pub const fn is_err(&self) -> bool
      Returns true if the result is Err.
      \n
      §Examples
      \n
      let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_err(), false);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_err(), true);
      Run
      \n
      1.70.0 · source
      pub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool
      Returns true if the result is Err and the value inside of it matches a predicate.
      \n
      §Examples
      \n
      use std::io::{Error, ErrorKind};\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);\n\nlet x: Result<u32, Error> = Ok(123);\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
      Run
      \n
      source
      pub fn ok(self) -> Option<T>
      Converts from Result<T, E> to Option<T>.
      \n
      Converts self into an Option<T>, consuming self,\nand discarding the error, if any.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.ok(), Some(2));\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.ok(), None);
      Run
      \n
      source
      pub fn err(self) -> Option<E>
      Converts from Result<T, E> to Option<E>.
      \n
      Converts self into an Option<E>, consuming self,\nand discarding the success value, if any.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.err(), None);\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.err(), Some(\"Nothing here\"));
      Run
      \n
      const: 1.48.0 · source
      pub const fn as_ref(&self) -> Result<&T, &E>
      Converts from &Result<T, E> to Result<&T, &E>.
      \n
      Produces a new Result, containing a reference\ninto the original, leaving the original in place.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.as_ref(), Ok(&2));\n\nlet x: Result<u32, &str> = Err(\"Error\");\nassert_eq!(x.as_ref(), Err(&\"Error\"));
      Run
      \n
      const: unstable · source
      pub fn as_mut(&mut self) -> Result<&mut T, &mut E>
      Converts from &mut Result<T, E> to Result<&mut T, &mut E>.
      \n
      §Examples
      \n
      fn mutate(r: &mut Result<i32, i32>) {\n    match r.as_mut() {\n        Ok(v) => *v = 42,\n        Err(e) => *e = 0,\n    }\n}\n\nlet mut x: Result<i32, i32> = Ok(2);\nmutate(&mut x);\nassert_eq!(x.unwrap(), 42);\n\nlet mut x: Result<i32, i32> = Err(13);\nmutate(&mut x);\nassert_eq!(x.unwrap_err(), 0);
      Run
      \n
      source
      pub fn map<U, F>(self, op: F) -> Result<U, E>
      where\n    F: FnOnce(T) -> U,
      Maps a Result<T, E> to Result<U, E> by applying a function to a\ncontained Ok value, leaving an Err value untouched.
      \n
      This function can be used to compose the results of two functions.
      \n
      §Examples
      \n
      Print the numbers on each line of a string multiplied by two.
      \n\n
      let line = \"1\\n2\\n3\\n4\\n\";\n\nfor num in line.lines() {\n    match num.parse::<i32>().map(|i| i * 2) {\n        Ok(n) => println!(\"{n}\"),\n        Err(..) => {}\n    }\n}
      Run
      \n
      1.41.0 · source
      pub fn map_or<U, F>(self, default: U, f: F) -> U
      where\n    F: FnOnce(T) -> U,
      Returns the provided default (if Err), or\napplies a function to the contained value (if Ok).
      \n
      Arguments passed to map_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use map_or_else,\nwhich is lazily evaluated.
      \n
      §Examples
      \n
      let x: Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or(42, |v| v.len()), 3);\n\nlet x: Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or(42, |v| v.len()), 42);
      Run
      \n
      1.41.0 · source
      pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
      where\n    D: FnOnce(E) -> U,\n    F: FnOnce(T) -> U,
      Maps a Result<T, E> to U by applying fallback function default to\na contained Err value, or function f to a contained Ok value.
      \n
      This function can be used to unpack a successful result\nwhile handling an error.
      \n
      §Examples
      \n
      let k = 21;\n\nlet x : Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);\n\nlet x : Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);
      Run
      \n
      source
      pub fn map_err<F, O>(self, op: O) -> Result<T, F>
      where\n    O: FnOnce(E) -> F,
      Maps a Result<T, E> to Result<T, F> by applying a function to a\ncontained Err value, leaving an Ok value untouched.
      \n
      This function can be used to pass through a successful result while handling\nan error.
      \n
      §Examples
      \n
      fn stringify(x: u32) -> String { format!(\"error code: {x}\") }\n\nlet x: Result<u32, u32> = Ok(2);\nassert_eq!(x.map_err(stringify), Ok(2));\n\nlet x: Result<u32, u32> = Err(13);\nassert_eq!(x.map_err(stringify), Err(\"error code: 13\".to_string()));
      Run
      \n
      1.76.0 · source
      pub fn inspect<F>(self, f: F) -> Result<T, E>
      where\n    F: FnOnce(&T),
      Calls a function with a reference to the contained value if Ok.
      \n
      Returns the original result.
      \n
      §Examples
      \n
      let x: u8 = \"4\"\n    .parse::<u8>()\n    .inspect(|x| println!(\"original: {x}\"))\n    .map(|x| x.pow(3))\n    .expect(\"failed to parse number\");
      Run
      \n
      1.76.0 · source
      pub fn inspect_err<F>(self, f: F) -> Result<T, E>
      where\n    F: FnOnce(&E),
      Calls a function with a reference to the contained value if Err.
      \n
      Returns the original result.
      \n
      §Examples
      \n
      use std::{fs, io};\n\nfn read() -> io::Result<String> {\n    fs::read_to_string(\"address.txt\")\n        .inspect_err(|e| eprintln!(\"failed to read file: {e}\"))\n}
      Run
      \n
      1.47.0 · source
      pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>
      where\n    T: Deref,
      Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.
      \n
      Coerces the Ok variant of the original Result via Deref\nand returns the new Result.
      \n
      §Examples
      \n
      let x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&str, &u32> = Ok(\"hello\");\nassert_eq!(x.as_deref(), y);\n\nlet x: Result<String, u32> = Err(42);\nlet y: Result<&str, &u32> = Err(&42);\nassert_eq!(x.as_deref(), y);
      Run
      \n
      1.47.0 · source
      pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>
      where\n    T: DerefMut,
      Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.
      \n
      Coerces the Ok variant of the original Result via DerefMut\nand returns the new Result.
      \n
      §Examples
      \n
      let mut s = \"HELLO\".to_string();\nlet mut x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&mut str, &mut u32> = Ok(&mut s);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);\n\nlet mut i = 42;\nlet mut x: Result<String, u32> = Err(42);\nlet y: Result<&mut str, &mut u32> = Err(&mut i);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
      Run
      \n
      source
      pub fn iter(&self) -> Iter<'_, T>
      Returns an iterator over the possibly contained value.
      \n
      The iterator yields one value if the result is Result::Ok, otherwise none.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(7);\nassert_eq!(x.iter().next(), Some(&7));\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter().next(), None);
      Run
      \n
      source
      pub fn iter_mut(&mut self) -> IterMut<'_, T>
      Returns a mutable iterator over the possibly contained value.
      \n
      The iterator yields one value if the result is Result::Ok, otherwise none.
      \n
      §Examples
      \n
      let mut x: Result<u32, &str> = Ok(7);\nmatch x.iter_mut().next() {\n    Some(v) => *v = 40,\n    None => {},\n}\nassert_eq!(x, Ok(40));\n\nlet mut x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter_mut().next(), None);
      Run
      \n
      1.4.0 · source
      pub fn expect(self, msg: &str) -> T
      where\n    E: Debug,
      Returns the contained Ok value, consuming the self value.
      \n
      Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.
      \n
      §Panics
      \n
      Panics if the value is an Err, with a panic message including the\npassed message, and the content of the Err.
      \n
      §Examples
      \n
      ⓘ
      let x: Result<u32, &str> = Err(\"emergency failure\");\nx.expect(\"Testing expect\"); // panics with `Testing expect: emergency failure`
      Run
      \n
      §Recommended Message Style
      \n
      We recommend that expect messages are used to describe the reason you\nexpect the Result should be Ok.
      \n\n
      ⓘ
      let path = std::env::var(\"IMPORTANT_PATH\")\n    .expect(\"env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`\");
      Run
      \n
      Hint: If you’re having trouble remembering how to phrase expect\nerror messages remember to focus on the word “should” as in “env\nvariable should be set by blah” or “the given binary should be available\nand executable by the current user”.
      \n
      For more detail on expect message styles and the reasoning behind our recommendation please\nrefer to the section on “Common Message\nStyles” in the\nstd::error module docs.
      \n
      source
      pub fn unwrap(self) -> T
      where\n    E: Debug,
      Returns the contained Ok value, consuming the self value.
      \n
      Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.
      \n
      §Panics
      \n
      Panics if the value is an Err, with a panic message provided by the\nErr’s value.
      \n
      §Examples
      \n
      Basic usage:
      \n\n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.unwrap(), 2);
      Run
      \n\n
      ⓘ
      let x: Result<u32, &str> = Err(\"emergency failure\");\nx.unwrap(); // panics with `emergency failure`
      Run
      \n
      1.16.0 · source
      pub fn unwrap_or_default(self) -> T
      where\n    T: Default,
      Returns the contained Ok value or a default
      \n
      Consumes the self argument then, if Ok, returns the contained\nvalue, otherwise if Err, returns the default value for that\ntype.
      \n
      §Examples
      \n
      Converts a string to an integer, turning poorly-formed strings\ninto 0 (the default value for integers). parse converts\na string to any other type that implements FromStr, returning an\nErr on error.
      \n\n
      let good_year_from_input = \"1909\";\nlet bad_year_from_input = \"190blarg\";\nlet good_year = good_year_from_input.parse().unwrap_or_default();\nlet bad_year = bad_year_from_input.parse().unwrap_or_default();\n\nassert_eq!(1909, good_year);\nassert_eq!(0, bad_year);
      Run
      \n
      1.17.0 · source
      pub fn expect_err(self, msg: &str) -> E
      where\n    T: Debug,
      Returns the contained Err value, consuming the self value.
      \n
      §Panics
      \n
      Panics if the value is an Ok, with a panic message including the\npassed message, and the content of the Ok.
      \n
      §Examples
      \n
      ⓘ
      let x: Result<u32, &str> = Ok(10);\nx.expect_err(\"Testing expect_err\"); // panics with `Testing expect_err: 10`
      Run
      \n
      source
      pub fn unwrap_err(self) -> E
      where\n    T: Debug,
      Returns the contained Err value, consuming the self value.
      \n
      §Panics
      \n
      Panics if the value is an Ok, with a custom panic message provided\nby the Ok’s value.
      \n
      §Examples
      \n
      ⓘ
      let x: Result<u32, &str> = Ok(2);\nx.unwrap_err(); // panics with `2`
      Run
      \n\n
      let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(x.unwrap_err(), \"emergency failure\");
      Run
      \n
      source
      pub fn into_ok(self) -> T
      where\n    E: Into<!>,
      🔬This is a nightly-only experimental API. (unwrap_infallible #61695)
      Returns the contained Ok value, but never panics.
      \n
      Unlike unwrap, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap as a maintainability safeguard that will fail\nto compile if the error type of the Result is later changed\nto an error that can actually occur.
      \n
      §Examples
      \n
      \nfn only_good_news() -> Result<String, !> {\n    Ok(\"this is fine\".into())\n}\n\nlet s: String = only_good_news().into_ok();\nprintln!(\"{s}\");
      Run
      \n
      source
      pub fn into_err(self) -> E
      where\n    T: Into<!>,
      🔬This is a nightly-only experimental API. (unwrap_infallible #61695)
      Returns the contained Err value, but never panics.
      \n
      Unlike unwrap_err, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap_err as a maintainability safeguard that will fail\nto compile if the ok type of the Result is later changed\nto a type that can actually occur.
      \n
      §Examples
      \n
      \nfn only_bad_news() -> Result<!, String> {\n    Err(\"Oops, it failed\".into())\n}\n\nlet error: String = only_bad_news().into_err();\nprintln!(\"{error}\");
      Run
      \n
      source
      pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>
      Returns res if the result is Ok, otherwise returns the Err value of self.
      \n
      Arguments passed to and are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use and_then, which is\nlazily evaluated.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<&str, &str> = Ok(\"foo\");\nassert_eq!(x.and(y), Err(\"early error\"));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"not a 2\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Ok(\"different result type\");\nassert_eq!(x.and(y), Ok(\"different result type\"));
      Run
      \n
      source
      pub fn and_then<U, F>(self, op: F) -> Result<U, E>
      where\n    F: FnOnce(T) -> Result<U, E>,
      Calls op if the result is Ok, otherwise returns the Err value of self.
      \n
      This function can be used for control flow based on Result values.
      \n
      §Examples
      \n
      fn sq_then_to_string(x: u32) -> Result<String, &'static str> {\n    x.checked_mul(x).map(|sq| sq.to_string()).ok_or(\"overflowed\")\n}\n\nassert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));\nassert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err(\"overflowed\"));\nassert_eq!(Err(\"not a number\").and_then(sq_then_to_string), Err(\"not a number\"));
      Run
      \n
      Often used to chain fallible operations that may return Err.
      \n\n
      use std::{io::ErrorKind, path::Path};\n\n// Note: on Windows \"/\" maps to \"C:\\\"\nlet root_modified_time = Path::new(\"/\").metadata().and_then(|md| md.modified());\nassert!(root_modified_time.is_ok());\n\nlet should_fail = Path::new(\"/bad/path\").metadata().and_then(|md| md.modified());\nassert!(should_fail.is_err());\nassert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
      Run
      \n
      source
      pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>
      Returns res if the result is Err, otherwise returns the Ok value of self.
      \n
      Arguments passed to or are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use or_else, which is\nlazily evaluated.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<u32, &str> = Ok(2);\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Ok(100);\nassert_eq!(x.or(y), Ok(2));
      Run
      \n
      source
      pub fn or_else<F, O>(self, op: O) -> Result<T, F>
      where\n    O: FnOnce(E) -> Result<T, F>,
      Calls op if the result is Err, otherwise returns the Ok value of self.
      \n
      This function can be used for control flow based on result values.
      \n
      §Examples
      \n
      fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }\nfn err(x: u32) -> Result<u32, u32> { Err(x) }\n\nassert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));\nassert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));\nassert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));\nassert_eq!(Err(3).or_else(err).or_else(err), Err(3));
      Run
      \n
      source
      pub fn unwrap_or(self, default: T) -> T
      Returns the contained Ok value or a provided default.
      \n
      Arguments passed to unwrap_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use unwrap_or_else,\nwhich is lazily evaluated.
      \n
      §Examples
      \n
      let default = 2;\nlet x: Result<u32, &str> = Ok(9);\nassert_eq!(x.unwrap_or(default), 9);\n\nlet x: Result<u32, &str> = Err(\"error\");\nassert_eq!(x.unwrap_or(default), default);
      Run
      \n
      source
      pub fn unwrap_or_else<F>(self, op: F) -> T
      where\n    F: FnOnce(E) -> T,
      Returns the contained Ok value or computes it from a closure.
      \n
      §Examples
      \n
      fn count(x: &str) -> usize { x.len() }\n\nassert_eq!(Ok(2).unwrap_or_else(count), 2);\nassert_eq!(Err(\"foo\").unwrap_or_else(count), 3);
      Run
      \n
      1.58.0 · source
      pub unsafe fn unwrap_unchecked(self) -> T
      Returns the contained Ok value, consuming the self value,\nwithout checking that the value is not an Err.
      \n
      §Safety
      \n
      Calling this method on an Err is undefined behavior.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nassert_eq!(unsafe { x.unwrap_unchecked() }, 2);
      Run
      \n\n
      let x: Result<u32, &str> = Err(\"emergency failure\");\nunsafe { x.unwrap_unchecked(); } // Undefined behavior!
      Run
      \n
      1.58.0 · source
      pub unsafe fn unwrap_err_unchecked(self) -> E
      Returns the contained Err value, consuming the self value,\nwithout checking that the value is not an Ok.
      \n
      §Safety
      \n
      Calling this method on an Ok is undefined behavior.
      \n
      §Examples
      \n
      let x: Result<u32, &str> = Ok(2);\nunsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
      Run
      \n\n
      let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(unsafe { x.unwrap_err_unchecked() }, \"emergency failure\");
      Run
      \n
      ", 0, "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      1.16.0 · source§
      impl<T, U, E> Sum<Result<U, E>> for Result<T, E>
      where\n    T: Sum<U>,
      source§
      fn sum<I>(iter: I) -> Result<T, E>
      where\n    I: Iterator<Item = Result<U, E>>,
      Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the sum of all elements is returned.
      \n
      §Examples
      \n
      This sums up every integer in a vector, rejecting the sum if a negative\nelement is encountered:
      \n\n
      let f = |&x: &i32| if x < 0 { Err(\"Negative element found\") } else { Ok(x) };\nlet v = vec![1, 2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Ok(3));\nlet v = vec![1, -2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Err(\"Negative element found\"));
      Run
      \n
      ", "Sum>", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E> Try for Result<T, E>
      §
      type Output = T
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      The type of the value produced by ? when not short-circuiting.
      §
      type Residual = Result<Infallible, E>
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      The type of the value passed to FromResidual::from_residual\nas part of ? when short-circuiting. Read more
      source§
      fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      Constructs the type from its Output type. Read more
      source§
      fn branch(\n    self\n) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      Used in ? to decide whether the operator should produce a value\n(because this returned ControlFlow::Continue)\nor propagate a value back to the caller\n(because this returned ControlFlow::Break). Read more
      ", "Try", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E> Copy for Result<T, E>
      where\n    T: Copy,\n    E: Copy,
      ", "Copy", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E> Eq for Result<T, E>
      where\n    T: Eq,\n    E: Eq,
      ", "Eq", "alloc::fmt::Result"],
│ │ │ │ │ +            ["
      source§
      impl<T, E> StructuralPartialEq for Result<T, E>
      ", "StructuralPartialEq", "alloc::fmt::Result"]
│ │ │ │ │          ],
│ │ │ │ │          "core": [
│ │ │ │ │              ["
      source§
      impl<T, E> Clone for Result<T, E>
      where\n    T: Clone,\n    E: Clone,
      source§
      fn clone(&self) -> Self
      Returns a copy of the value. Read more
      source§
      fn clone_from(&mut self, source: &Self)
      Performs copy-assignment from source. Read more
      ", "Clone", "core::fmt::Result"],
│ │ │ │ │              ["
      source§
      impl<T: Debug, E: Debug> Debug for Result<T, E>
      source§
      fn fmt(&self, f: &mut Formatter<'_>) -> Result
      Formats the value using the given formatter. Read more
      ", "Debug", "core::fmt::Result"],
│ │ │ │ │              ["
      source§
      impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E>
      source§
      fn from_iter<I: IntoIterator<Item = Result<A, E>>>(iter: I) -> Result<V, E>
      Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err occur, a\ncontainer with the values of each Result is returned.
      \n
      Here is an example which increments every integer in a vector,\nchecking for overflow:
      \n\n
      let v = vec![1, 2];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_add(1).ok_or(\"Overflow!\")\n).collect();\nassert_eq!(res, Ok(vec![2, 3]));
      Run
      \n
      Here is another example that tries to subtract one from another list\nof integers, this time checking for underflow:
      \n\n
      let v = vec![1, 2, 0];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_sub(1).ok_or(\"Underflow!\")\n).collect();\nassert_eq!(res, Err(\"Underflow!\"));
      Run
      \n
      Here is a variation on the previous example, showing that no\nfurther elements are taken from iter after the first Err.
      \n\n
      let v = vec![3, 2, 1, 10];\nlet mut shared = 0;\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {\n    shared += x;\n    x.checked_sub(2).ok_or(\"Underflow!\")\n}).collect();\nassert_eq!(res, Err(\"Underflow!\"));\nassert_eq!(shared, 6);
      Run
      \n
      Since the third element caused an underflow, no further elements were taken,\nso the final value of shared is 6 (= 3 + 2 + 1), not 16.
      \n
      ", "FromIterator>", "core::fmt::Result"],
│ │ │ │ │              ["
      source§
      impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Result<T, F>
      source§
      fn from_residual(residual: Result<Infallible, E>) -> Self
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      Constructs the type from a compatible Residual type. Read more
      ", "FromResidual>", "core::fmt::Result"],
│ │ │ │ │              ["
      source§
      impl<T, E, F: From<E>> FromResidual<Yeet<E>> for Result<T, F>
      source§
      fn from_residual(ops::Yeet: Yeet<E>) -> Self
      🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
      Constructs the type from a compatible Residual type. Read more
      ", "FromResidual>", "core::fmt::Result"],

    Pattern typeMatch condition
    &stris substring
    charis contained in string
    &[char]any char in slice is contained in string
    F: FnMut(char) -> boolF returns true for a char in string
    &&stris substring