1use core::{
2 cmp::Ordering,
3 iter::{Product, Sum},
4};
5pub mod iter1 {
6 use super::*;
7 use core::iter::FusedIterator;
8 #[derive(Debug, Clone, Copy)]
9 pub enum Iter1<I0> {
10 I0(I0),
11 }
12 pub trait IntoIter0: IntoIterator {
13 #[allow(clippy::type_complexity)]
14 fn into_iter0(self) -> Iter1<Self::IntoIter>;
15 }
16 impl<T: IntoIterator> IntoIter0 for T {
17 #[allow(clippy::type_complexity)]
18 fn into_iter0(self) -> Iter1<Self::IntoIter> {
19 Iter1::I0(self.into_iter())
20 }
21 }
22 impl<Item, I0> Iterator for Iter1<I0>
23 where
24 I0: Iterator<Item = Item>,
25 {
26 type Item = Item;
27 fn next(&mut self) -> Option<Self::Item> {
28 match self {
29 Self::I0(this) => this.next(),
30 }
31 }
32 fn size_hint(&self) -> (usize, Option<usize>) {
33 match self {
34 Self::I0(this) => this.size_hint(),
35 }
36 }
37 fn count(self) -> usize
38 where
39 Self: Sized,
40 {
41 match self {
42 Self::I0(this) => this.count(),
43 }
44 }
45 fn last(self) -> Option<Self::Item>
46 where
47 Self: Sized,
48 {
49 match self {
50 Self::I0(this) => this.last(),
51 }
52 }
53 fn nth(&mut self, n: usize) -> Option<Self::Item> {
54 match self {
55 Self::I0(this) => this.nth(n),
56 }
57 }
58 fn for_each<F>(self, f: F)
59 where
60 Self: Sized,
61 F: FnMut(Self::Item),
62 {
63 match self {
64 Self::I0(this) => this.for_each(f),
65 }
66 }
67 fn collect<B: FromIterator<Self::Item>>(self) -> B
68 where
69 Self: Sized,
70 {
71 match self {
72 Self::I0(this) => this.collect(),
73 }
74 }
75 fn partition<B, F>(self, f: F) -> (B, B)
76 where
77 Self: Sized,
78 B: Default + Extend<Self::Item>,
79 F: FnMut(&Self::Item) -> bool,
80 {
81 match self {
82 Self::I0(this) => this.partition(f),
83 }
84 }
85 fn fold<B, F>(self, init: B, f: F) -> B
86 where
87 Self: Sized,
88 F: FnMut(B, Self::Item) -> B,
89 {
90 match self {
91 Self::I0(this) => this.fold(init, f),
92 }
93 }
94 fn reduce<F>(self, f: F) -> Option<Self::Item>
95 where
96 Self: Sized,
97 F: FnMut(Self::Item, Self::Item) -> Self::Item,
98 {
99 match self {
100 Self::I0(this) => this.reduce(f),
101 }
102 }
103 fn all<F>(&mut self, f: F) -> bool
104 where
105 Self: Sized,
106 F: FnMut(Self::Item) -> bool,
107 {
108 match self {
109 Self::I0(this) => this.all(f),
110 }
111 }
112 fn any<F>(&mut self, f: F) -> bool
113 where
114 Self: Sized,
115 F: FnMut(Self::Item) -> bool,
116 {
117 match self {
118 Self::I0(this) => this.any(f),
119 }
120 }
121 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
122 where
123 Self: Sized,
124 P: FnMut(&Self::Item) -> bool,
125 {
126 match self {
127 Self::I0(this) => this.find(predicate),
128 }
129 }
130 fn find_map<B, F>(&mut self, f: F) -> Option<B>
131 where
132 Self: Sized,
133 F: FnMut(Self::Item) -> Option<B>,
134 {
135 match self {
136 Self::I0(this) => this.find_map(f),
137 }
138 }
139 fn position<P>(&mut self, predicate: P) -> Option<usize>
140 where
141 Self: Sized,
142 P: FnMut(Self::Item) -> bool,
143 {
144 match self {
145 Self::I0(this) => this.position(predicate),
146 }
147 }
148 fn max(self) -> Option<Self::Item>
149 where
150 Self: Sized,
151 Self::Item: Ord,
152 {
153 match self {
154 Self::I0(this) => this.max(),
155 }
156 }
157 fn min(self) -> Option<Self::Item>
158 where
159 Self: Sized,
160 Self::Item: Ord,
161 {
162 match self {
163 Self::I0(this) => this.min(),
164 }
165 }
166 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
167 where
168 Self: Sized,
169 F: FnMut(&Self::Item) -> B,
170 {
171 match self {
172 Self::I0(this) => this.max_by_key(f),
173 }
174 }
175 fn max_by<F>(self, compare: F) -> Option<Self::Item>
176 where
177 Self: Sized,
178 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
179 {
180 match self {
181 Self::I0(this) => this.max_by(compare),
182 }
183 }
184 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
185 where
186 Self: Sized,
187 F: FnMut(&Self::Item) -> B,
188 {
189 match self {
190 Self::I0(this) => this.min_by_key(f),
191 }
192 }
193 fn min_by<F>(self, compare: F) -> Option<Self::Item>
194 where
195 Self: Sized,
196 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
197 {
198 match self {
199 Self::I0(this) => this.min_by(compare),
200 }
201 }
202 fn sum<S>(self) -> S
203 where
204 Self: Sized,
205 S: Sum<Self::Item>,
206 {
207 match self {
208 Self::I0(this) => this.sum(),
209 }
210 }
211 fn product<P>(self) -> P
212 where
213 Self: Sized,
214 P: Product<Self::Item>,
215 {
216 match self {
217 Self::I0(this) => this.product(),
218 }
219 }
220 fn cmp<I>(self, other: I) -> Ordering
221 where
222 I: IntoIterator<Item = Self::Item>,
223 Self::Item: Ord,
224 Self: Sized,
225 {
226 match self {
227 Self::I0(this) => this.cmp(other),
228 }
229 }
230 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
231 where
232 I: IntoIterator,
233 Self::Item: PartialOrd<I::Item>,
234 Self: Sized,
235 {
236 match self {
237 Self::I0(this) => this.partial_cmp(other),
238 }
239 }
240 fn eq<I>(self, other: I) -> bool
241 where
242 I: IntoIterator,
243 Self::Item: PartialEq<I::Item>,
244 Self: Sized,
245 {
246 match self {
247 Self::I0(this) => this.eq(other),
248 }
249 }
250 fn ne<I>(self, other: I) -> bool
251 where
252 I: IntoIterator,
253 Self::Item: PartialEq<I::Item>,
254 Self: Sized,
255 {
256 match self {
257 Self::I0(this) => this.ne(other),
258 }
259 }
260 fn lt<I>(self, other: I) -> bool
261 where
262 I: IntoIterator,
263 Self::Item: PartialOrd<I::Item>,
264 Self: Sized,
265 {
266 match self {
267 Self::I0(this) => this.lt(other),
268 }
269 }
270 fn le<I>(self, other: I) -> bool
271 where
272 I: IntoIterator,
273 Self::Item: PartialOrd<I::Item>,
274 Self: Sized,
275 {
276 match self {
277 Self::I0(this) => this.le(other),
278 }
279 }
280 fn gt<I>(self, other: I) -> bool
281 where
282 I: IntoIterator,
283 Self::Item: PartialOrd<I::Item>,
284 Self: Sized,
285 {
286 match self {
287 Self::I0(this) => this.gt(other),
288 }
289 }
290 fn ge<I>(self, other: I) -> bool
291 where
292 I: IntoIterator,
293 Self::Item: PartialOrd<I::Item>,
294 Self: Sized,
295 {
296 match self {
297 Self::I0(this) => this.ge(other),
298 }
299 }
300 }
301 impl<Item, I0> DoubleEndedIterator for Iter1<I0>
302 where
303 I0: DoubleEndedIterator<Item = Item>,
304 {
305 fn next_back(&mut self) -> Option<Self::Item> {
306 match self {
307 Self::I0(this) => this.next_back(),
308 }
309 }
310 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
311 match self {
312 Self::I0(this) => this.nth_back(n),
313 }
314 }
315 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
316 where
317 P: FnMut(&Self::Item) -> bool,
318 {
319 match self {
320 Self::I0(this) => this.rfind(predicate),
321 }
322 }
323 fn rfold<B, F>(self, init: B, f: F) -> B
324 where
325 Self: Sized,
326 F: FnMut(B, Self::Item) -> B,
327 {
328 match self {
329 Self::I0(this) => this.rfold(init, f),
330 }
331 }
332 }
333 impl<Item, I0> ExactSizeIterator for Iter1<I0>
334 where
335 I0: ExactSizeIterator<Item = Item>,
336 {
337 fn len(&self) -> usize {
338 match self {
339 Self::I0(this) => this.len(),
340 }
341 }
342 }
343 impl<Item, I0> FusedIterator for Iter1<I0> where I0: FusedIterator<Item = Item> {}
344}
345pub mod iter2 {
346 use super::*;
347 use core::iter::FusedIterator;
348 #[derive(Debug, Clone, Copy)]
349 pub enum Iter2<I0, I1> {
350 I0(I0),
351 I1(I1),
352 }
353 pub trait IntoIter0: IntoIterator {
354 #[allow(clippy::type_complexity)]
355 fn into_iter0<I1>(self) -> Iter2<Self::IntoIter, I1>;
356 }
357 impl<T: IntoIterator> IntoIter0 for T {
358 #[allow(clippy::type_complexity)]
359 fn into_iter0<I1>(self) -> Iter2<Self::IntoIter, I1> {
360 Iter2::I0(self.into_iter())
361 }
362 }
363 pub trait IntoIter1: IntoIterator {
364 #[allow(clippy::type_complexity)]
365 fn into_iter1<I0>(self) -> Iter2<I0, Self::IntoIter>;
366 }
367 impl<T: IntoIterator> IntoIter1 for T {
368 #[allow(clippy::type_complexity)]
369 fn into_iter1<I0>(self) -> Iter2<I0, Self::IntoIter> {
370 Iter2::I1(self.into_iter())
371 }
372 }
373 impl<Item, I0, I1> Iterator for Iter2<I0, I1>
374 where
375 I0: Iterator<Item = Item>,
376 I1: Iterator<Item = Item>,
377 {
378 type Item = Item;
379 fn next(&mut self) -> Option<Self::Item> {
380 match self {
381 Self::I0(this) => this.next(),
382 Self::I1(this) => this.next(),
383 }
384 }
385 fn size_hint(&self) -> (usize, Option<usize>) {
386 match self {
387 Self::I0(this) => this.size_hint(),
388 Self::I1(this) => this.size_hint(),
389 }
390 }
391 fn count(self) -> usize
392 where
393 Self: Sized,
394 {
395 match self {
396 Self::I0(this) => this.count(),
397 Self::I1(this) => this.count(),
398 }
399 }
400 fn last(self) -> Option<Self::Item>
401 where
402 Self: Sized,
403 {
404 match self {
405 Self::I0(this) => this.last(),
406 Self::I1(this) => this.last(),
407 }
408 }
409 fn nth(&mut self, n: usize) -> Option<Self::Item> {
410 match self {
411 Self::I0(this) => this.nth(n),
412 Self::I1(this) => this.nth(n),
413 }
414 }
415 fn for_each<F>(self, f: F)
416 where
417 Self: Sized,
418 F: FnMut(Self::Item),
419 {
420 match self {
421 Self::I0(this) => this.for_each(f),
422 Self::I1(this) => this.for_each(f),
423 }
424 }
425 fn collect<B: FromIterator<Self::Item>>(self) -> B
426 where
427 Self: Sized,
428 {
429 match self {
430 Self::I0(this) => this.collect(),
431 Self::I1(this) => this.collect(),
432 }
433 }
434 fn partition<B, F>(self, f: F) -> (B, B)
435 where
436 Self: Sized,
437 B: Default + Extend<Self::Item>,
438 F: FnMut(&Self::Item) -> bool,
439 {
440 match self {
441 Self::I0(this) => this.partition(f),
442 Self::I1(this) => this.partition(f),
443 }
444 }
445 fn fold<B, F>(self, init: B, f: F) -> B
446 where
447 Self: Sized,
448 F: FnMut(B, Self::Item) -> B,
449 {
450 match self {
451 Self::I0(this) => this.fold(init, f),
452 Self::I1(this) => this.fold(init, f),
453 }
454 }
455 fn reduce<F>(self, f: F) -> Option<Self::Item>
456 where
457 Self: Sized,
458 F: FnMut(Self::Item, Self::Item) -> Self::Item,
459 {
460 match self {
461 Self::I0(this) => this.reduce(f),
462 Self::I1(this) => this.reduce(f),
463 }
464 }
465 fn all<F>(&mut self, f: F) -> bool
466 where
467 Self: Sized,
468 F: FnMut(Self::Item) -> bool,
469 {
470 match self {
471 Self::I0(this) => this.all(f),
472 Self::I1(this) => this.all(f),
473 }
474 }
475 fn any<F>(&mut self, f: F) -> bool
476 where
477 Self: Sized,
478 F: FnMut(Self::Item) -> bool,
479 {
480 match self {
481 Self::I0(this) => this.any(f),
482 Self::I1(this) => this.any(f),
483 }
484 }
485 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
486 where
487 Self: Sized,
488 P: FnMut(&Self::Item) -> bool,
489 {
490 match self {
491 Self::I0(this) => this.find(predicate),
492 Self::I1(this) => this.find(predicate),
493 }
494 }
495 fn find_map<B, F>(&mut self, f: F) -> Option<B>
496 where
497 Self: Sized,
498 F: FnMut(Self::Item) -> Option<B>,
499 {
500 match self {
501 Self::I0(this) => this.find_map(f),
502 Self::I1(this) => this.find_map(f),
503 }
504 }
505 fn position<P>(&mut self, predicate: P) -> Option<usize>
506 where
507 Self: Sized,
508 P: FnMut(Self::Item) -> bool,
509 {
510 match self {
511 Self::I0(this) => this.position(predicate),
512 Self::I1(this) => this.position(predicate),
513 }
514 }
515 fn max(self) -> Option<Self::Item>
516 where
517 Self: Sized,
518 Self::Item: Ord,
519 {
520 match self {
521 Self::I0(this) => this.max(),
522 Self::I1(this) => this.max(),
523 }
524 }
525 fn min(self) -> Option<Self::Item>
526 where
527 Self: Sized,
528 Self::Item: Ord,
529 {
530 match self {
531 Self::I0(this) => this.min(),
532 Self::I1(this) => this.min(),
533 }
534 }
535 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
536 where
537 Self: Sized,
538 F: FnMut(&Self::Item) -> B,
539 {
540 match self {
541 Self::I0(this) => this.max_by_key(f),
542 Self::I1(this) => this.max_by_key(f),
543 }
544 }
545 fn max_by<F>(self, compare: F) -> Option<Self::Item>
546 where
547 Self: Sized,
548 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
549 {
550 match self {
551 Self::I0(this) => this.max_by(compare),
552 Self::I1(this) => this.max_by(compare),
553 }
554 }
555 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
556 where
557 Self: Sized,
558 F: FnMut(&Self::Item) -> B,
559 {
560 match self {
561 Self::I0(this) => this.min_by_key(f),
562 Self::I1(this) => this.min_by_key(f),
563 }
564 }
565 fn min_by<F>(self, compare: F) -> Option<Self::Item>
566 where
567 Self: Sized,
568 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
569 {
570 match self {
571 Self::I0(this) => this.min_by(compare),
572 Self::I1(this) => this.min_by(compare),
573 }
574 }
575 fn sum<S>(self) -> S
576 where
577 Self: Sized,
578 S: Sum<Self::Item>,
579 {
580 match self {
581 Self::I0(this) => this.sum(),
582 Self::I1(this) => this.sum(),
583 }
584 }
585 fn product<P>(self) -> P
586 where
587 Self: Sized,
588 P: Product<Self::Item>,
589 {
590 match self {
591 Self::I0(this) => this.product(),
592 Self::I1(this) => this.product(),
593 }
594 }
595 fn cmp<I>(self, other: I) -> Ordering
596 where
597 I: IntoIterator<Item = Self::Item>,
598 Self::Item: Ord,
599 Self: Sized,
600 {
601 match self {
602 Self::I0(this) => this.cmp(other),
603 Self::I1(this) => this.cmp(other),
604 }
605 }
606 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
607 where
608 I: IntoIterator,
609 Self::Item: PartialOrd<I::Item>,
610 Self: Sized,
611 {
612 match self {
613 Self::I0(this) => this.partial_cmp(other),
614 Self::I1(this) => this.partial_cmp(other),
615 }
616 }
617 fn eq<I>(self, other: I) -> bool
618 where
619 I: IntoIterator,
620 Self::Item: PartialEq<I::Item>,
621 Self: Sized,
622 {
623 match self {
624 Self::I0(this) => this.eq(other),
625 Self::I1(this) => this.eq(other),
626 }
627 }
628 fn ne<I>(self, other: I) -> bool
629 where
630 I: IntoIterator,
631 Self::Item: PartialEq<I::Item>,
632 Self: Sized,
633 {
634 match self {
635 Self::I0(this) => this.ne(other),
636 Self::I1(this) => this.ne(other),
637 }
638 }
639 fn lt<I>(self, other: I) -> bool
640 where
641 I: IntoIterator,
642 Self::Item: PartialOrd<I::Item>,
643 Self: Sized,
644 {
645 match self {
646 Self::I0(this) => this.lt(other),
647 Self::I1(this) => this.lt(other),
648 }
649 }
650 fn le<I>(self, other: I) -> bool
651 where
652 I: IntoIterator,
653 Self::Item: PartialOrd<I::Item>,
654 Self: Sized,
655 {
656 match self {
657 Self::I0(this) => this.le(other),
658 Self::I1(this) => this.le(other),
659 }
660 }
661 fn gt<I>(self, other: I) -> bool
662 where
663 I: IntoIterator,
664 Self::Item: PartialOrd<I::Item>,
665 Self: Sized,
666 {
667 match self {
668 Self::I0(this) => this.gt(other),
669 Self::I1(this) => this.gt(other),
670 }
671 }
672 fn ge<I>(self, other: I) -> bool
673 where
674 I: IntoIterator,
675 Self::Item: PartialOrd<I::Item>,
676 Self: Sized,
677 {
678 match self {
679 Self::I0(this) => this.ge(other),
680 Self::I1(this) => this.ge(other),
681 }
682 }
683 }
684 impl<Item, I0, I1> DoubleEndedIterator for Iter2<I0, I1>
685 where
686 I0: DoubleEndedIterator<Item = Item>,
687 I1: DoubleEndedIterator<Item = Item>,
688 {
689 fn next_back(&mut self) -> Option<Self::Item> {
690 match self {
691 Self::I0(this) => this.next_back(),
692 Self::I1(this) => this.next_back(),
693 }
694 }
695 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
696 match self {
697 Self::I0(this) => this.nth_back(n),
698 Self::I1(this) => this.nth_back(n),
699 }
700 }
701 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
702 where
703 P: FnMut(&Self::Item) -> bool,
704 {
705 match self {
706 Self::I0(this) => this.rfind(predicate),
707 Self::I1(this) => this.rfind(predicate),
708 }
709 }
710 fn rfold<B, F>(self, init: B, f: F) -> B
711 where
712 Self: Sized,
713 F: FnMut(B, Self::Item) -> B,
714 {
715 match self {
716 Self::I0(this) => this.rfold(init, f),
717 Self::I1(this) => this.rfold(init, f),
718 }
719 }
720 }
721 impl<Item, I0, I1> ExactSizeIterator for Iter2<I0, I1>
722 where
723 I0: ExactSizeIterator<Item = Item>,
724 I1: ExactSizeIterator<Item = Item>,
725 {
726 fn len(&self) -> usize {
727 match self {
728 Self::I0(this) => this.len(),
729 Self::I1(this) => this.len(),
730 }
731 }
732 }
733 impl<Item, I0, I1> FusedIterator for Iter2<I0, I1>
734 where
735 I0: FusedIterator<Item = Item>,
736 I1: FusedIterator<Item = Item>,
737 {
738 }
739}
740pub mod iter3 {
741 use super::*;
742 use core::iter::FusedIterator;
743 #[derive(Debug, Clone, Copy)]
744 pub enum Iter3<I0, I1, I2> {
745 I0(I0),
746 I1(I1),
747 I2(I2),
748 }
749 pub trait IntoIter0: IntoIterator {
750 #[allow(clippy::type_complexity)]
751 fn into_iter0<I1, I2>(self) -> Iter3<Self::IntoIter, I1, I2>;
752 }
753 impl<T: IntoIterator> IntoIter0 for T {
754 #[allow(clippy::type_complexity)]
755 fn into_iter0<I1, I2>(self) -> Iter3<Self::IntoIter, I1, I2> {
756 Iter3::I0(self.into_iter())
757 }
758 }
759 pub trait IntoIter1: IntoIterator {
760 #[allow(clippy::type_complexity)]
761 fn into_iter1<I0, I2>(self) -> Iter3<I0, Self::IntoIter, I2>;
762 }
763 impl<T: IntoIterator> IntoIter1 for T {
764 #[allow(clippy::type_complexity)]
765 fn into_iter1<I0, I2>(self) -> Iter3<I0, Self::IntoIter, I2> {
766 Iter3::I1(self.into_iter())
767 }
768 }
769 pub trait IntoIter2: IntoIterator {
770 #[allow(clippy::type_complexity)]
771 fn into_iter2<I0, I1>(self) -> Iter3<I0, I1, Self::IntoIter>;
772 }
773 impl<T: IntoIterator> IntoIter2 for T {
774 #[allow(clippy::type_complexity)]
775 fn into_iter2<I0, I1>(self) -> Iter3<I0, I1, Self::IntoIter> {
776 Iter3::I2(self.into_iter())
777 }
778 }
779 impl<Item, I0, I1, I2> Iterator for Iter3<I0, I1, I2>
780 where
781 I0: Iterator<Item = Item>,
782 I1: Iterator<Item = Item>,
783 I2: Iterator<Item = Item>,
784 {
785 type Item = Item;
786 fn next(&mut self) -> Option<Self::Item> {
787 match self {
788 Self::I0(this) => this.next(),
789 Self::I1(this) => this.next(),
790 Self::I2(this) => this.next(),
791 }
792 }
793 fn size_hint(&self) -> (usize, Option<usize>) {
794 match self {
795 Self::I0(this) => this.size_hint(),
796 Self::I1(this) => this.size_hint(),
797 Self::I2(this) => this.size_hint(),
798 }
799 }
800 fn count(self) -> usize
801 where
802 Self: Sized,
803 {
804 match self {
805 Self::I0(this) => this.count(),
806 Self::I1(this) => this.count(),
807 Self::I2(this) => this.count(),
808 }
809 }
810 fn last(self) -> Option<Self::Item>
811 where
812 Self: Sized,
813 {
814 match self {
815 Self::I0(this) => this.last(),
816 Self::I1(this) => this.last(),
817 Self::I2(this) => this.last(),
818 }
819 }
820 fn nth(&mut self, n: usize) -> Option<Self::Item> {
821 match self {
822 Self::I0(this) => this.nth(n),
823 Self::I1(this) => this.nth(n),
824 Self::I2(this) => this.nth(n),
825 }
826 }
827 fn for_each<F>(self, f: F)
828 where
829 Self: Sized,
830 F: FnMut(Self::Item),
831 {
832 match self {
833 Self::I0(this) => this.for_each(f),
834 Self::I1(this) => this.for_each(f),
835 Self::I2(this) => this.for_each(f),
836 }
837 }
838 fn collect<B: FromIterator<Self::Item>>(self) -> B
839 where
840 Self: Sized,
841 {
842 match self {
843 Self::I0(this) => this.collect(),
844 Self::I1(this) => this.collect(),
845 Self::I2(this) => this.collect(),
846 }
847 }
848 fn partition<B, F>(self, f: F) -> (B, B)
849 where
850 Self: Sized,
851 B: Default + Extend<Self::Item>,
852 F: FnMut(&Self::Item) -> bool,
853 {
854 match self {
855 Self::I0(this) => this.partition(f),
856 Self::I1(this) => this.partition(f),
857 Self::I2(this) => this.partition(f),
858 }
859 }
860 fn fold<B, F>(self, init: B, f: F) -> B
861 where
862 Self: Sized,
863 F: FnMut(B, Self::Item) -> B,
864 {
865 match self {
866 Self::I0(this) => this.fold(init, f),
867 Self::I1(this) => this.fold(init, f),
868 Self::I2(this) => this.fold(init, f),
869 }
870 }
871 fn reduce<F>(self, f: F) -> Option<Self::Item>
872 where
873 Self: Sized,
874 F: FnMut(Self::Item, Self::Item) -> Self::Item,
875 {
876 match self {
877 Self::I0(this) => this.reduce(f),
878 Self::I1(this) => this.reduce(f),
879 Self::I2(this) => this.reduce(f),
880 }
881 }
882 fn all<F>(&mut self, f: F) -> bool
883 where
884 Self: Sized,
885 F: FnMut(Self::Item) -> bool,
886 {
887 match self {
888 Self::I0(this) => this.all(f),
889 Self::I1(this) => this.all(f),
890 Self::I2(this) => this.all(f),
891 }
892 }
893 fn any<F>(&mut self, f: F) -> bool
894 where
895 Self: Sized,
896 F: FnMut(Self::Item) -> bool,
897 {
898 match self {
899 Self::I0(this) => this.any(f),
900 Self::I1(this) => this.any(f),
901 Self::I2(this) => this.any(f),
902 }
903 }
904 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
905 where
906 Self: Sized,
907 P: FnMut(&Self::Item) -> bool,
908 {
909 match self {
910 Self::I0(this) => this.find(predicate),
911 Self::I1(this) => this.find(predicate),
912 Self::I2(this) => this.find(predicate),
913 }
914 }
915 fn find_map<B, F>(&mut self, f: F) -> Option<B>
916 where
917 Self: Sized,
918 F: FnMut(Self::Item) -> Option<B>,
919 {
920 match self {
921 Self::I0(this) => this.find_map(f),
922 Self::I1(this) => this.find_map(f),
923 Self::I2(this) => this.find_map(f),
924 }
925 }
926 fn position<P>(&mut self, predicate: P) -> Option<usize>
927 where
928 Self: Sized,
929 P: FnMut(Self::Item) -> bool,
930 {
931 match self {
932 Self::I0(this) => this.position(predicate),
933 Self::I1(this) => this.position(predicate),
934 Self::I2(this) => this.position(predicate),
935 }
936 }
937 fn max(self) -> Option<Self::Item>
938 where
939 Self: Sized,
940 Self::Item: Ord,
941 {
942 match self {
943 Self::I0(this) => this.max(),
944 Self::I1(this) => this.max(),
945 Self::I2(this) => this.max(),
946 }
947 }
948 fn min(self) -> Option<Self::Item>
949 where
950 Self: Sized,
951 Self::Item: Ord,
952 {
953 match self {
954 Self::I0(this) => this.min(),
955 Self::I1(this) => this.min(),
956 Self::I2(this) => this.min(),
957 }
958 }
959 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
960 where
961 Self: Sized,
962 F: FnMut(&Self::Item) -> B,
963 {
964 match self {
965 Self::I0(this) => this.max_by_key(f),
966 Self::I1(this) => this.max_by_key(f),
967 Self::I2(this) => this.max_by_key(f),
968 }
969 }
970 fn max_by<F>(self, compare: F) -> Option<Self::Item>
971 where
972 Self: Sized,
973 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
974 {
975 match self {
976 Self::I0(this) => this.max_by(compare),
977 Self::I1(this) => this.max_by(compare),
978 Self::I2(this) => this.max_by(compare),
979 }
980 }
981 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
982 where
983 Self: Sized,
984 F: FnMut(&Self::Item) -> B,
985 {
986 match self {
987 Self::I0(this) => this.min_by_key(f),
988 Self::I1(this) => this.min_by_key(f),
989 Self::I2(this) => this.min_by_key(f),
990 }
991 }
992 fn min_by<F>(self, compare: F) -> Option<Self::Item>
993 where
994 Self: Sized,
995 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
996 {
997 match self {
998 Self::I0(this) => this.min_by(compare),
999 Self::I1(this) => this.min_by(compare),
1000 Self::I2(this) => this.min_by(compare),
1001 }
1002 }
1003 fn sum<S>(self) -> S
1004 where
1005 Self: Sized,
1006 S: Sum<Self::Item>,
1007 {
1008 match self {
1009 Self::I0(this) => this.sum(),
1010 Self::I1(this) => this.sum(),
1011 Self::I2(this) => this.sum(),
1012 }
1013 }
1014 fn product<P>(self) -> P
1015 where
1016 Self: Sized,
1017 P: Product<Self::Item>,
1018 {
1019 match self {
1020 Self::I0(this) => this.product(),
1021 Self::I1(this) => this.product(),
1022 Self::I2(this) => this.product(),
1023 }
1024 }
1025 fn cmp<I>(self, other: I) -> Ordering
1026 where
1027 I: IntoIterator<Item = Self::Item>,
1028 Self::Item: Ord,
1029 Self: Sized,
1030 {
1031 match self {
1032 Self::I0(this) => this.cmp(other),
1033 Self::I1(this) => this.cmp(other),
1034 Self::I2(this) => this.cmp(other),
1035 }
1036 }
1037 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
1038 where
1039 I: IntoIterator,
1040 Self::Item: PartialOrd<I::Item>,
1041 Self: Sized,
1042 {
1043 match self {
1044 Self::I0(this) => this.partial_cmp(other),
1045 Self::I1(this) => this.partial_cmp(other),
1046 Self::I2(this) => this.partial_cmp(other),
1047 }
1048 }
1049 fn eq<I>(self, other: I) -> bool
1050 where
1051 I: IntoIterator,
1052 Self::Item: PartialEq<I::Item>,
1053 Self: Sized,
1054 {
1055 match self {
1056 Self::I0(this) => this.eq(other),
1057 Self::I1(this) => this.eq(other),
1058 Self::I2(this) => this.eq(other),
1059 }
1060 }
1061 fn ne<I>(self, other: I) -> bool
1062 where
1063 I: IntoIterator,
1064 Self::Item: PartialEq<I::Item>,
1065 Self: Sized,
1066 {
1067 match self {
1068 Self::I0(this) => this.ne(other),
1069 Self::I1(this) => this.ne(other),
1070 Self::I2(this) => this.ne(other),
1071 }
1072 }
1073 fn lt<I>(self, other: I) -> bool
1074 where
1075 I: IntoIterator,
1076 Self::Item: PartialOrd<I::Item>,
1077 Self: Sized,
1078 {
1079 match self {
1080 Self::I0(this) => this.lt(other),
1081 Self::I1(this) => this.lt(other),
1082 Self::I2(this) => this.lt(other),
1083 }
1084 }
1085 fn le<I>(self, other: I) -> bool
1086 where
1087 I: IntoIterator,
1088 Self::Item: PartialOrd<I::Item>,
1089 Self: Sized,
1090 {
1091 match self {
1092 Self::I0(this) => this.le(other),
1093 Self::I1(this) => this.le(other),
1094 Self::I2(this) => this.le(other),
1095 }
1096 }
1097 fn gt<I>(self, other: I) -> bool
1098 where
1099 I: IntoIterator,
1100 Self::Item: PartialOrd<I::Item>,
1101 Self: Sized,
1102 {
1103 match self {
1104 Self::I0(this) => this.gt(other),
1105 Self::I1(this) => this.gt(other),
1106 Self::I2(this) => this.gt(other),
1107 }
1108 }
1109 fn ge<I>(self, other: I) -> bool
1110 where
1111 I: IntoIterator,
1112 Self::Item: PartialOrd<I::Item>,
1113 Self: Sized,
1114 {
1115 match self {
1116 Self::I0(this) => this.ge(other),
1117 Self::I1(this) => this.ge(other),
1118 Self::I2(this) => this.ge(other),
1119 }
1120 }
1121 }
1122 impl<Item, I0, I1, I2> DoubleEndedIterator for Iter3<I0, I1, I2>
1123 where
1124 I0: DoubleEndedIterator<Item = Item>,
1125 I1: DoubleEndedIterator<Item = Item>,
1126 I2: DoubleEndedIterator<Item = Item>,
1127 {
1128 fn next_back(&mut self) -> Option<Self::Item> {
1129 match self {
1130 Self::I0(this) => this.next_back(),
1131 Self::I1(this) => this.next_back(),
1132 Self::I2(this) => this.next_back(),
1133 }
1134 }
1135 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
1136 match self {
1137 Self::I0(this) => this.nth_back(n),
1138 Self::I1(this) => this.nth_back(n),
1139 Self::I2(this) => this.nth_back(n),
1140 }
1141 }
1142 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
1143 where
1144 P: FnMut(&Self::Item) -> bool,
1145 {
1146 match self {
1147 Self::I0(this) => this.rfind(predicate),
1148 Self::I1(this) => this.rfind(predicate),
1149 Self::I2(this) => this.rfind(predicate),
1150 }
1151 }
1152 fn rfold<B, F>(self, init: B, f: F) -> B
1153 where
1154 Self: Sized,
1155 F: FnMut(B, Self::Item) -> B,
1156 {
1157 match self {
1158 Self::I0(this) => this.rfold(init, f),
1159 Self::I1(this) => this.rfold(init, f),
1160 Self::I2(this) => this.rfold(init, f),
1161 }
1162 }
1163 }
1164 impl<Item, I0, I1, I2> ExactSizeIterator for Iter3<I0, I1, I2>
1165 where
1166 I0: ExactSizeIterator<Item = Item>,
1167 I1: ExactSizeIterator<Item = Item>,
1168 I2: ExactSizeIterator<Item = Item>,
1169 {
1170 fn len(&self) -> usize {
1171 match self {
1172 Self::I0(this) => this.len(),
1173 Self::I1(this) => this.len(),
1174 Self::I2(this) => this.len(),
1175 }
1176 }
1177 }
1178 impl<Item, I0, I1, I2> FusedIterator for Iter3<I0, I1, I2>
1179 where
1180 I0: FusedIterator<Item = Item>,
1181 I1: FusedIterator<Item = Item>,
1182 I2: FusedIterator<Item = Item>,
1183 {
1184 }
1185}
1186pub mod iter4 {
1187 use super::*;
1188 use core::iter::FusedIterator;
1189 #[derive(Debug, Clone, Copy)]
1190 pub enum Iter4<I0, I1, I2, I3> {
1191 I0(I0),
1192 I1(I1),
1193 I2(I2),
1194 I3(I3),
1195 }
1196 pub trait IntoIter0: IntoIterator {
1197 #[allow(clippy::type_complexity)]
1198 fn into_iter0<I1, I2, I3>(self) -> Iter4<Self::IntoIter, I1, I2, I3>;
1199 }
1200 impl<T: IntoIterator> IntoIter0 for T {
1201 #[allow(clippy::type_complexity)]
1202 fn into_iter0<I1, I2, I3>(self) -> Iter4<Self::IntoIter, I1, I2, I3> {
1203 Iter4::I0(self.into_iter())
1204 }
1205 }
1206 pub trait IntoIter1: IntoIterator {
1207 #[allow(clippy::type_complexity)]
1208 fn into_iter1<I0, I2, I3>(self) -> Iter4<I0, Self::IntoIter, I2, I3>;
1209 }
1210 impl<T: IntoIterator> IntoIter1 for T {
1211 #[allow(clippy::type_complexity)]
1212 fn into_iter1<I0, I2, I3>(self) -> Iter4<I0, Self::IntoIter, I2, I3> {
1213 Iter4::I1(self.into_iter())
1214 }
1215 }
1216 pub trait IntoIter2: IntoIterator {
1217 #[allow(clippy::type_complexity)]
1218 fn into_iter2<I0, I1, I3>(self) -> Iter4<I0, I1, Self::IntoIter, I3>;
1219 }
1220 impl<T: IntoIterator> IntoIter2 for T {
1221 #[allow(clippy::type_complexity)]
1222 fn into_iter2<I0, I1, I3>(self) -> Iter4<I0, I1, Self::IntoIter, I3> {
1223 Iter4::I2(self.into_iter())
1224 }
1225 }
1226 pub trait IntoIter3: IntoIterator {
1227 #[allow(clippy::type_complexity)]
1228 fn into_iter3<I0, I1, I2>(self) -> Iter4<I0, I1, I2, Self::IntoIter>;
1229 }
1230 impl<T: IntoIterator> IntoIter3 for T {
1231 #[allow(clippy::type_complexity)]
1232 fn into_iter3<I0, I1, I2>(self) -> Iter4<I0, I1, I2, Self::IntoIter> {
1233 Iter4::I3(self.into_iter())
1234 }
1235 }
1236 impl<Item, I0, I1, I2, I3> Iterator for Iter4<I0, I1, I2, I3>
1237 where
1238 I0: Iterator<Item = Item>,
1239 I1: Iterator<Item = Item>,
1240 I2: Iterator<Item = Item>,
1241 I3: Iterator<Item = Item>,
1242 {
1243 type Item = Item;
1244 fn next(&mut self) -> Option<Self::Item> {
1245 match self {
1246 Self::I0(this) => this.next(),
1247 Self::I1(this) => this.next(),
1248 Self::I2(this) => this.next(),
1249 Self::I3(this) => this.next(),
1250 }
1251 }
1252 fn size_hint(&self) -> (usize, Option<usize>) {
1253 match self {
1254 Self::I0(this) => this.size_hint(),
1255 Self::I1(this) => this.size_hint(),
1256 Self::I2(this) => this.size_hint(),
1257 Self::I3(this) => this.size_hint(),
1258 }
1259 }
1260 fn count(self) -> usize
1261 where
1262 Self: Sized,
1263 {
1264 match self {
1265 Self::I0(this) => this.count(),
1266 Self::I1(this) => this.count(),
1267 Self::I2(this) => this.count(),
1268 Self::I3(this) => this.count(),
1269 }
1270 }
1271 fn last(self) -> Option<Self::Item>
1272 where
1273 Self: Sized,
1274 {
1275 match self {
1276 Self::I0(this) => this.last(),
1277 Self::I1(this) => this.last(),
1278 Self::I2(this) => this.last(),
1279 Self::I3(this) => this.last(),
1280 }
1281 }
1282 fn nth(&mut self, n: usize) -> Option<Self::Item> {
1283 match self {
1284 Self::I0(this) => this.nth(n),
1285 Self::I1(this) => this.nth(n),
1286 Self::I2(this) => this.nth(n),
1287 Self::I3(this) => this.nth(n),
1288 }
1289 }
1290 fn for_each<F>(self, f: F)
1291 where
1292 Self: Sized,
1293 F: FnMut(Self::Item),
1294 {
1295 match self {
1296 Self::I0(this) => this.for_each(f),
1297 Self::I1(this) => this.for_each(f),
1298 Self::I2(this) => this.for_each(f),
1299 Self::I3(this) => this.for_each(f),
1300 }
1301 }
1302 fn collect<B: FromIterator<Self::Item>>(self) -> B
1303 where
1304 Self: Sized,
1305 {
1306 match self {
1307 Self::I0(this) => this.collect(),
1308 Self::I1(this) => this.collect(),
1309 Self::I2(this) => this.collect(),
1310 Self::I3(this) => this.collect(),
1311 }
1312 }
1313 fn partition<B, F>(self, f: F) -> (B, B)
1314 where
1315 Self: Sized,
1316 B: Default + Extend<Self::Item>,
1317 F: FnMut(&Self::Item) -> bool,
1318 {
1319 match self {
1320 Self::I0(this) => this.partition(f),
1321 Self::I1(this) => this.partition(f),
1322 Self::I2(this) => this.partition(f),
1323 Self::I3(this) => this.partition(f),
1324 }
1325 }
1326 fn fold<B, F>(self, init: B, f: F) -> B
1327 where
1328 Self: Sized,
1329 F: FnMut(B, Self::Item) -> B,
1330 {
1331 match self {
1332 Self::I0(this) => this.fold(init, f),
1333 Self::I1(this) => this.fold(init, f),
1334 Self::I2(this) => this.fold(init, f),
1335 Self::I3(this) => this.fold(init, f),
1336 }
1337 }
1338 fn reduce<F>(self, f: F) -> Option<Self::Item>
1339 where
1340 Self: Sized,
1341 F: FnMut(Self::Item, Self::Item) -> Self::Item,
1342 {
1343 match self {
1344 Self::I0(this) => this.reduce(f),
1345 Self::I1(this) => this.reduce(f),
1346 Self::I2(this) => this.reduce(f),
1347 Self::I3(this) => this.reduce(f),
1348 }
1349 }
1350 fn all<F>(&mut self, f: F) -> bool
1351 where
1352 Self: Sized,
1353 F: FnMut(Self::Item) -> bool,
1354 {
1355 match self {
1356 Self::I0(this) => this.all(f),
1357 Self::I1(this) => this.all(f),
1358 Self::I2(this) => this.all(f),
1359 Self::I3(this) => this.all(f),
1360 }
1361 }
1362 fn any<F>(&mut self, f: F) -> bool
1363 where
1364 Self: Sized,
1365 F: FnMut(Self::Item) -> bool,
1366 {
1367 match self {
1368 Self::I0(this) => this.any(f),
1369 Self::I1(this) => this.any(f),
1370 Self::I2(this) => this.any(f),
1371 Self::I3(this) => this.any(f),
1372 }
1373 }
1374 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1375 where
1376 Self: Sized,
1377 P: FnMut(&Self::Item) -> bool,
1378 {
1379 match self {
1380 Self::I0(this) => this.find(predicate),
1381 Self::I1(this) => this.find(predicate),
1382 Self::I2(this) => this.find(predicate),
1383 Self::I3(this) => this.find(predicate),
1384 }
1385 }
1386 fn find_map<B, F>(&mut self, f: F) -> Option<B>
1387 where
1388 Self: Sized,
1389 F: FnMut(Self::Item) -> Option<B>,
1390 {
1391 match self {
1392 Self::I0(this) => this.find_map(f),
1393 Self::I1(this) => this.find_map(f),
1394 Self::I2(this) => this.find_map(f),
1395 Self::I3(this) => this.find_map(f),
1396 }
1397 }
1398 fn position<P>(&mut self, predicate: P) -> Option<usize>
1399 where
1400 Self: Sized,
1401 P: FnMut(Self::Item) -> bool,
1402 {
1403 match self {
1404 Self::I0(this) => this.position(predicate),
1405 Self::I1(this) => this.position(predicate),
1406 Self::I2(this) => this.position(predicate),
1407 Self::I3(this) => this.position(predicate),
1408 }
1409 }
1410 fn max(self) -> Option<Self::Item>
1411 where
1412 Self: Sized,
1413 Self::Item: Ord,
1414 {
1415 match self {
1416 Self::I0(this) => this.max(),
1417 Self::I1(this) => this.max(),
1418 Self::I2(this) => this.max(),
1419 Self::I3(this) => this.max(),
1420 }
1421 }
1422 fn min(self) -> Option<Self::Item>
1423 where
1424 Self: Sized,
1425 Self::Item: Ord,
1426 {
1427 match self {
1428 Self::I0(this) => this.min(),
1429 Self::I1(this) => this.min(),
1430 Self::I2(this) => this.min(),
1431 Self::I3(this) => this.min(),
1432 }
1433 }
1434 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
1435 where
1436 Self: Sized,
1437 F: FnMut(&Self::Item) -> B,
1438 {
1439 match self {
1440 Self::I0(this) => this.max_by_key(f),
1441 Self::I1(this) => this.max_by_key(f),
1442 Self::I2(this) => this.max_by_key(f),
1443 Self::I3(this) => this.max_by_key(f),
1444 }
1445 }
1446 fn max_by<F>(self, compare: F) -> Option<Self::Item>
1447 where
1448 Self: Sized,
1449 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1450 {
1451 match self {
1452 Self::I0(this) => this.max_by(compare),
1453 Self::I1(this) => this.max_by(compare),
1454 Self::I2(this) => this.max_by(compare),
1455 Self::I3(this) => this.max_by(compare),
1456 }
1457 }
1458 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
1459 where
1460 Self: Sized,
1461 F: FnMut(&Self::Item) -> B,
1462 {
1463 match self {
1464 Self::I0(this) => this.min_by_key(f),
1465 Self::I1(this) => this.min_by_key(f),
1466 Self::I2(this) => this.min_by_key(f),
1467 Self::I3(this) => this.min_by_key(f),
1468 }
1469 }
1470 fn min_by<F>(self, compare: F) -> Option<Self::Item>
1471 where
1472 Self: Sized,
1473 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1474 {
1475 match self {
1476 Self::I0(this) => this.min_by(compare),
1477 Self::I1(this) => this.min_by(compare),
1478 Self::I2(this) => this.min_by(compare),
1479 Self::I3(this) => this.min_by(compare),
1480 }
1481 }
1482 fn sum<S>(self) -> S
1483 where
1484 Self: Sized,
1485 S: Sum<Self::Item>,
1486 {
1487 match self {
1488 Self::I0(this) => this.sum(),
1489 Self::I1(this) => this.sum(),
1490 Self::I2(this) => this.sum(),
1491 Self::I3(this) => this.sum(),
1492 }
1493 }
1494 fn product<P>(self) -> P
1495 where
1496 Self: Sized,
1497 P: Product<Self::Item>,
1498 {
1499 match self {
1500 Self::I0(this) => this.product(),
1501 Self::I1(this) => this.product(),
1502 Self::I2(this) => this.product(),
1503 Self::I3(this) => this.product(),
1504 }
1505 }
1506 fn cmp<I>(self, other: I) -> Ordering
1507 where
1508 I: IntoIterator<Item = Self::Item>,
1509 Self::Item: Ord,
1510 Self: Sized,
1511 {
1512 match self {
1513 Self::I0(this) => this.cmp(other),
1514 Self::I1(this) => this.cmp(other),
1515 Self::I2(this) => this.cmp(other),
1516 Self::I3(this) => this.cmp(other),
1517 }
1518 }
1519 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
1520 where
1521 I: IntoIterator,
1522 Self::Item: PartialOrd<I::Item>,
1523 Self: Sized,
1524 {
1525 match self {
1526 Self::I0(this) => this.partial_cmp(other),
1527 Self::I1(this) => this.partial_cmp(other),
1528 Self::I2(this) => this.partial_cmp(other),
1529 Self::I3(this) => this.partial_cmp(other),
1530 }
1531 }
1532 fn eq<I>(self, other: I) -> bool
1533 where
1534 I: IntoIterator,
1535 Self::Item: PartialEq<I::Item>,
1536 Self: Sized,
1537 {
1538 match self {
1539 Self::I0(this) => this.eq(other),
1540 Self::I1(this) => this.eq(other),
1541 Self::I2(this) => this.eq(other),
1542 Self::I3(this) => this.eq(other),
1543 }
1544 }
1545 fn ne<I>(self, other: I) -> bool
1546 where
1547 I: IntoIterator,
1548 Self::Item: PartialEq<I::Item>,
1549 Self: Sized,
1550 {
1551 match self {
1552 Self::I0(this) => this.ne(other),
1553 Self::I1(this) => this.ne(other),
1554 Self::I2(this) => this.ne(other),
1555 Self::I3(this) => this.ne(other),
1556 }
1557 }
1558 fn lt<I>(self, other: I) -> bool
1559 where
1560 I: IntoIterator,
1561 Self::Item: PartialOrd<I::Item>,
1562 Self: Sized,
1563 {
1564 match self {
1565 Self::I0(this) => this.lt(other),
1566 Self::I1(this) => this.lt(other),
1567 Self::I2(this) => this.lt(other),
1568 Self::I3(this) => this.lt(other),
1569 }
1570 }
1571 fn le<I>(self, other: I) -> bool
1572 where
1573 I: IntoIterator,
1574 Self::Item: PartialOrd<I::Item>,
1575 Self: Sized,
1576 {
1577 match self {
1578 Self::I0(this) => this.le(other),
1579 Self::I1(this) => this.le(other),
1580 Self::I2(this) => this.le(other),
1581 Self::I3(this) => this.le(other),
1582 }
1583 }
1584 fn gt<I>(self, other: I) -> bool
1585 where
1586 I: IntoIterator,
1587 Self::Item: PartialOrd<I::Item>,
1588 Self: Sized,
1589 {
1590 match self {
1591 Self::I0(this) => this.gt(other),
1592 Self::I1(this) => this.gt(other),
1593 Self::I2(this) => this.gt(other),
1594 Self::I3(this) => this.gt(other),
1595 }
1596 }
1597 fn ge<I>(self, other: I) -> bool
1598 where
1599 I: IntoIterator,
1600 Self::Item: PartialOrd<I::Item>,
1601 Self: Sized,
1602 {
1603 match self {
1604 Self::I0(this) => this.ge(other),
1605 Self::I1(this) => this.ge(other),
1606 Self::I2(this) => this.ge(other),
1607 Self::I3(this) => this.ge(other),
1608 }
1609 }
1610 }
1611 impl<Item, I0, I1, I2, I3> DoubleEndedIterator for Iter4<I0, I1, I2, I3>
1612 where
1613 I0: DoubleEndedIterator<Item = Item>,
1614 I1: DoubleEndedIterator<Item = Item>,
1615 I2: DoubleEndedIterator<Item = Item>,
1616 I3: DoubleEndedIterator<Item = Item>,
1617 {
1618 fn next_back(&mut self) -> Option<Self::Item> {
1619 match self {
1620 Self::I0(this) => this.next_back(),
1621 Self::I1(this) => this.next_back(),
1622 Self::I2(this) => this.next_back(),
1623 Self::I3(this) => this.next_back(),
1624 }
1625 }
1626 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
1627 match self {
1628 Self::I0(this) => this.nth_back(n),
1629 Self::I1(this) => this.nth_back(n),
1630 Self::I2(this) => this.nth_back(n),
1631 Self::I3(this) => this.nth_back(n),
1632 }
1633 }
1634 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
1635 where
1636 P: FnMut(&Self::Item) -> bool,
1637 {
1638 match self {
1639 Self::I0(this) => this.rfind(predicate),
1640 Self::I1(this) => this.rfind(predicate),
1641 Self::I2(this) => this.rfind(predicate),
1642 Self::I3(this) => this.rfind(predicate),
1643 }
1644 }
1645 fn rfold<B, F>(self, init: B, f: F) -> B
1646 where
1647 Self: Sized,
1648 F: FnMut(B, Self::Item) -> B,
1649 {
1650 match self {
1651 Self::I0(this) => this.rfold(init, f),
1652 Self::I1(this) => this.rfold(init, f),
1653 Self::I2(this) => this.rfold(init, f),
1654 Self::I3(this) => this.rfold(init, f),
1655 }
1656 }
1657 }
1658 impl<Item, I0, I1, I2, I3> ExactSizeIterator for Iter4<I0, I1, I2, I3>
1659 where
1660 I0: ExactSizeIterator<Item = Item>,
1661 I1: ExactSizeIterator<Item = Item>,
1662 I2: ExactSizeIterator<Item = Item>,
1663 I3: ExactSizeIterator<Item = Item>,
1664 {
1665 fn len(&self) -> usize {
1666 match self {
1667 Self::I0(this) => this.len(),
1668 Self::I1(this) => this.len(),
1669 Self::I2(this) => this.len(),
1670 Self::I3(this) => this.len(),
1671 }
1672 }
1673 }
1674 impl<Item, I0, I1, I2, I3> FusedIterator for Iter4<I0, I1, I2, I3>
1675 where
1676 I0: FusedIterator<Item = Item>,
1677 I1: FusedIterator<Item = Item>,
1678 I2: FusedIterator<Item = Item>,
1679 I3: FusedIterator<Item = Item>,
1680 {
1681 }
1682}
1683pub mod iter5 {
1684 use super::*;
1685 use core::iter::FusedIterator;
1686 #[derive(Debug, Clone, Copy)]
1687 pub enum Iter5<I0, I1, I2, I3, I4> {
1688 I0(I0),
1689 I1(I1),
1690 I2(I2),
1691 I3(I3),
1692 I4(I4),
1693 }
1694 pub trait IntoIter0: IntoIterator {
1695 #[allow(clippy::type_complexity)]
1696 fn into_iter0<I1, I2, I3, I4>(self) -> Iter5<Self::IntoIter, I1, I2, I3, I4>;
1697 }
1698 impl<T: IntoIterator> IntoIter0 for T {
1699 #[allow(clippy::type_complexity)]
1700 fn into_iter0<I1, I2, I3, I4>(self) -> Iter5<Self::IntoIter, I1, I2, I3, I4> {
1701 Iter5::I0(self.into_iter())
1702 }
1703 }
1704 pub trait IntoIter1: IntoIterator {
1705 #[allow(clippy::type_complexity)]
1706 fn into_iter1<I0, I2, I3, I4>(self) -> Iter5<I0, Self::IntoIter, I2, I3, I4>;
1707 }
1708 impl<T: IntoIterator> IntoIter1 for T {
1709 #[allow(clippy::type_complexity)]
1710 fn into_iter1<I0, I2, I3, I4>(self) -> Iter5<I0, Self::IntoIter, I2, I3, I4> {
1711 Iter5::I1(self.into_iter())
1712 }
1713 }
1714 pub trait IntoIter2: IntoIterator {
1715 #[allow(clippy::type_complexity)]
1716 fn into_iter2<I0, I1, I3, I4>(self) -> Iter5<I0, I1, Self::IntoIter, I3, I4>;
1717 }
1718 impl<T: IntoIterator> IntoIter2 for T {
1719 #[allow(clippy::type_complexity)]
1720 fn into_iter2<I0, I1, I3, I4>(self) -> Iter5<I0, I1, Self::IntoIter, I3, I4> {
1721 Iter5::I2(self.into_iter())
1722 }
1723 }
1724 pub trait IntoIter3: IntoIterator {
1725 #[allow(clippy::type_complexity)]
1726 fn into_iter3<I0, I1, I2, I4>(self) -> Iter5<I0, I1, I2, Self::IntoIter, I4>;
1727 }
1728 impl<T: IntoIterator> IntoIter3 for T {
1729 #[allow(clippy::type_complexity)]
1730 fn into_iter3<I0, I1, I2, I4>(self) -> Iter5<I0, I1, I2, Self::IntoIter, I4> {
1731 Iter5::I3(self.into_iter())
1732 }
1733 }
1734 pub trait IntoIter4: IntoIterator {
1735 #[allow(clippy::type_complexity)]
1736 fn into_iter4<I0, I1, I2, I3>(self) -> Iter5<I0, I1, I2, I3, Self::IntoIter>;
1737 }
1738 impl<T: IntoIterator> IntoIter4 for T {
1739 #[allow(clippy::type_complexity)]
1740 fn into_iter4<I0, I1, I2, I3>(self) -> Iter5<I0, I1, I2, I3, Self::IntoIter> {
1741 Iter5::I4(self.into_iter())
1742 }
1743 }
1744 impl<Item, I0, I1, I2, I3, I4> Iterator for Iter5<I0, I1, I2, I3, I4>
1745 where
1746 I0: Iterator<Item = Item>,
1747 I1: Iterator<Item = Item>,
1748 I2: Iterator<Item = Item>,
1749 I3: Iterator<Item = Item>,
1750 I4: Iterator<Item = Item>,
1751 {
1752 type Item = Item;
1753 fn next(&mut self) -> Option<Self::Item> {
1754 match self {
1755 Self::I0(this) => this.next(),
1756 Self::I1(this) => this.next(),
1757 Self::I2(this) => this.next(),
1758 Self::I3(this) => this.next(),
1759 Self::I4(this) => this.next(),
1760 }
1761 }
1762 fn size_hint(&self) -> (usize, Option<usize>) {
1763 match self {
1764 Self::I0(this) => this.size_hint(),
1765 Self::I1(this) => this.size_hint(),
1766 Self::I2(this) => this.size_hint(),
1767 Self::I3(this) => this.size_hint(),
1768 Self::I4(this) => this.size_hint(),
1769 }
1770 }
1771 fn count(self) -> usize
1772 where
1773 Self: Sized,
1774 {
1775 match self {
1776 Self::I0(this) => this.count(),
1777 Self::I1(this) => this.count(),
1778 Self::I2(this) => this.count(),
1779 Self::I3(this) => this.count(),
1780 Self::I4(this) => this.count(),
1781 }
1782 }
1783 fn last(self) -> Option<Self::Item>
1784 where
1785 Self: Sized,
1786 {
1787 match self {
1788 Self::I0(this) => this.last(),
1789 Self::I1(this) => this.last(),
1790 Self::I2(this) => this.last(),
1791 Self::I3(this) => this.last(),
1792 Self::I4(this) => this.last(),
1793 }
1794 }
1795 fn nth(&mut self, n: usize) -> Option<Self::Item> {
1796 match self {
1797 Self::I0(this) => this.nth(n),
1798 Self::I1(this) => this.nth(n),
1799 Self::I2(this) => this.nth(n),
1800 Self::I3(this) => this.nth(n),
1801 Self::I4(this) => this.nth(n),
1802 }
1803 }
1804 fn for_each<F>(self, f: F)
1805 where
1806 Self: Sized,
1807 F: FnMut(Self::Item),
1808 {
1809 match self {
1810 Self::I0(this) => this.for_each(f),
1811 Self::I1(this) => this.for_each(f),
1812 Self::I2(this) => this.for_each(f),
1813 Self::I3(this) => this.for_each(f),
1814 Self::I4(this) => this.for_each(f),
1815 }
1816 }
1817 fn collect<B: FromIterator<Self::Item>>(self) -> B
1818 where
1819 Self: Sized,
1820 {
1821 match self {
1822 Self::I0(this) => this.collect(),
1823 Self::I1(this) => this.collect(),
1824 Self::I2(this) => this.collect(),
1825 Self::I3(this) => this.collect(),
1826 Self::I4(this) => this.collect(),
1827 }
1828 }
1829 fn partition<B, F>(self, f: F) -> (B, B)
1830 where
1831 Self: Sized,
1832 B: Default + Extend<Self::Item>,
1833 F: FnMut(&Self::Item) -> bool,
1834 {
1835 match self {
1836 Self::I0(this) => this.partition(f),
1837 Self::I1(this) => this.partition(f),
1838 Self::I2(this) => this.partition(f),
1839 Self::I3(this) => this.partition(f),
1840 Self::I4(this) => this.partition(f),
1841 }
1842 }
1843 fn fold<B, F>(self, init: B, f: F) -> B
1844 where
1845 Self: Sized,
1846 F: FnMut(B, Self::Item) -> B,
1847 {
1848 match self {
1849 Self::I0(this) => this.fold(init, f),
1850 Self::I1(this) => this.fold(init, f),
1851 Self::I2(this) => this.fold(init, f),
1852 Self::I3(this) => this.fold(init, f),
1853 Self::I4(this) => this.fold(init, f),
1854 }
1855 }
1856 fn reduce<F>(self, f: F) -> Option<Self::Item>
1857 where
1858 Self: Sized,
1859 F: FnMut(Self::Item, Self::Item) -> Self::Item,
1860 {
1861 match self {
1862 Self::I0(this) => this.reduce(f),
1863 Self::I1(this) => this.reduce(f),
1864 Self::I2(this) => this.reduce(f),
1865 Self::I3(this) => this.reduce(f),
1866 Self::I4(this) => this.reduce(f),
1867 }
1868 }
1869 fn all<F>(&mut self, f: F) -> bool
1870 where
1871 Self: Sized,
1872 F: FnMut(Self::Item) -> bool,
1873 {
1874 match self {
1875 Self::I0(this) => this.all(f),
1876 Self::I1(this) => this.all(f),
1877 Self::I2(this) => this.all(f),
1878 Self::I3(this) => this.all(f),
1879 Self::I4(this) => this.all(f),
1880 }
1881 }
1882 fn any<F>(&mut self, f: F) -> bool
1883 where
1884 Self: Sized,
1885 F: FnMut(Self::Item) -> bool,
1886 {
1887 match self {
1888 Self::I0(this) => this.any(f),
1889 Self::I1(this) => this.any(f),
1890 Self::I2(this) => this.any(f),
1891 Self::I3(this) => this.any(f),
1892 Self::I4(this) => this.any(f),
1893 }
1894 }
1895 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1896 where
1897 Self: Sized,
1898 P: FnMut(&Self::Item) -> bool,
1899 {
1900 match self {
1901 Self::I0(this) => this.find(predicate),
1902 Self::I1(this) => this.find(predicate),
1903 Self::I2(this) => this.find(predicate),
1904 Self::I3(this) => this.find(predicate),
1905 Self::I4(this) => this.find(predicate),
1906 }
1907 }
1908 fn find_map<B, F>(&mut self, f: F) -> Option<B>
1909 where
1910 Self: Sized,
1911 F: FnMut(Self::Item) -> Option<B>,
1912 {
1913 match self {
1914 Self::I0(this) => this.find_map(f),
1915 Self::I1(this) => this.find_map(f),
1916 Self::I2(this) => this.find_map(f),
1917 Self::I3(this) => this.find_map(f),
1918 Self::I4(this) => this.find_map(f),
1919 }
1920 }
1921 fn position<P>(&mut self, predicate: P) -> Option<usize>
1922 where
1923 Self: Sized,
1924 P: FnMut(Self::Item) -> bool,
1925 {
1926 match self {
1927 Self::I0(this) => this.position(predicate),
1928 Self::I1(this) => this.position(predicate),
1929 Self::I2(this) => this.position(predicate),
1930 Self::I3(this) => this.position(predicate),
1931 Self::I4(this) => this.position(predicate),
1932 }
1933 }
1934 fn max(self) -> Option<Self::Item>
1935 where
1936 Self: Sized,
1937 Self::Item: Ord,
1938 {
1939 match self {
1940 Self::I0(this) => this.max(),
1941 Self::I1(this) => this.max(),
1942 Self::I2(this) => this.max(),
1943 Self::I3(this) => this.max(),
1944 Self::I4(this) => this.max(),
1945 }
1946 }
1947 fn min(self) -> Option<Self::Item>
1948 where
1949 Self: Sized,
1950 Self::Item: Ord,
1951 {
1952 match self {
1953 Self::I0(this) => this.min(),
1954 Self::I1(this) => this.min(),
1955 Self::I2(this) => this.min(),
1956 Self::I3(this) => this.min(),
1957 Self::I4(this) => this.min(),
1958 }
1959 }
1960 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
1961 where
1962 Self: Sized,
1963 F: FnMut(&Self::Item) -> B,
1964 {
1965 match self {
1966 Self::I0(this) => this.max_by_key(f),
1967 Self::I1(this) => this.max_by_key(f),
1968 Self::I2(this) => this.max_by_key(f),
1969 Self::I3(this) => this.max_by_key(f),
1970 Self::I4(this) => this.max_by_key(f),
1971 }
1972 }
1973 fn max_by<F>(self, compare: F) -> Option<Self::Item>
1974 where
1975 Self: Sized,
1976 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1977 {
1978 match self {
1979 Self::I0(this) => this.max_by(compare),
1980 Self::I1(this) => this.max_by(compare),
1981 Self::I2(this) => this.max_by(compare),
1982 Self::I3(this) => this.max_by(compare),
1983 Self::I4(this) => this.max_by(compare),
1984 }
1985 }
1986 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
1987 where
1988 Self: Sized,
1989 F: FnMut(&Self::Item) -> B,
1990 {
1991 match self {
1992 Self::I0(this) => this.min_by_key(f),
1993 Self::I1(this) => this.min_by_key(f),
1994 Self::I2(this) => this.min_by_key(f),
1995 Self::I3(this) => this.min_by_key(f),
1996 Self::I4(this) => this.min_by_key(f),
1997 }
1998 }
1999 fn min_by<F>(self, compare: F) -> Option<Self::Item>
2000 where
2001 Self: Sized,
2002 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
2003 {
2004 match self {
2005 Self::I0(this) => this.min_by(compare),
2006 Self::I1(this) => this.min_by(compare),
2007 Self::I2(this) => this.min_by(compare),
2008 Self::I3(this) => this.min_by(compare),
2009 Self::I4(this) => this.min_by(compare),
2010 }
2011 }
2012 fn sum<S>(self) -> S
2013 where
2014 Self: Sized,
2015 S: Sum<Self::Item>,
2016 {
2017 match self {
2018 Self::I0(this) => this.sum(),
2019 Self::I1(this) => this.sum(),
2020 Self::I2(this) => this.sum(),
2021 Self::I3(this) => this.sum(),
2022 Self::I4(this) => this.sum(),
2023 }
2024 }
2025 fn product<P>(self) -> P
2026 where
2027 Self: Sized,
2028 P: Product<Self::Item>,
2029 {
2030 match self {
2031 Self::I0(this) => this.product(),
2032 Self::I1(this) => this.product(),
2033 Self::I2(this) => this.product(),
2034 Self::I3(this) => this.product(),
2035 Self::I4(this) => this.product(),
2036 }
2037 }
2038 fn cmp<I>(self, other: I) -> Ordering
2039 where
2040 I: IntoIterator<Item = Self::Item>,
2041 Self::Item: Ord,
2042 Self: Sized,
2043 {
2044 match self {
2045 Self::I0(this) => this.cmp(other),
2046 Self::I1(this) => this.cmp(other),
2047 Self::I2(this) => this.cmp(other),
2048 Self::I3(this) => this.cmp(other),
2049 Self::I4(this) => this.cmp(other),
2050 }
2051 }
2052 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
2053 where
2054 I: IntoIterator,
2055 Self::Item: PartialOrd<I::Item>,
2056 Self: Sized,
2057 {
2058 match self {
2059 Self::I0(this) => this.partial_cmp(other),
2060 Self::I1(this) => this.partial_cmp(other),
2061 Self::I2(this) => this.partial_cmp(other),
2062 Self::I3(this) => this.partial_cmp(other),
2063 Self::I4(this) => this.partial_cmp(other),
2064 }
2065 }
2066 fn eq<I>(self, other: I) -> bool
2067 where
2068 I: IntoIterator,
2069 Self::Item: PartialEq<I::Item>,
2070 Self: Sized,
2071 {
2072 match self {
2073 Self::I0(this) => this.eq(other),
2074 Self::I1(this) => this.eq(other),
2075 Self::I2(this) => this.eq(other),
2076 Self::I3(this) => this.eq(other),
2077 Self::I4(this) => this.eq(other),
2078 }
2079 }
2080 fn ne<I>(self, other: I) -> bool
2081 where
2082 I: IntoIterator,
2083 Self::Item: PartialEq<I::Item>,
2084 Self: Sized,
2085 {
2086 match self {
2087 Self::I0(this) => this.ne(other),
2088 Self::I1(this) => this.ne(other),
2089 Self::I2(this) => this.ne(other),
2090 Self::I3(this) => this.ne(other),
2091 Self::I4(this) => this.ne(other),
2092 }
2093 }
2094 fn lt<I>(self, other: I) -> bool
2095 where
2096 I: IntoIterator,
2097 Self::Item: PartialOrd<I::Item>,
2098 Self: Sized,
2099 {
2100 match self {
2101 Self::I0(this) => this.lt(other),
2102 Self::I1(this) => this.lt(other),
2103 Self::I2(this) => this.lt(other),
2104 Self::I3(this) => this.lt(other),
2105 Self::I4(this) => this.lt(other),
2106 }
2107 }
2108 fn le<I>(self, other: I) -> bool
2109 where
2110 I: IntoIterator,
2111 Self::Item: PartialOrd<I::Item>,
2112 Self: Sized,
2113 {
2114 match self {
2115 Self::I0(this) => this.le(other),
2116 Self::I1(this) => this.le(other),
2117 Self::I2(this) => this.le(other),
2118 Self::I3(this) => this.le(other),
2119 Self::I4(this) => this.le(other),
2120 }
2121 }
2122 fn gt<I>(self, other: I) -> bool
2123 where
2124 I: IntoIterator,
2125 Self::Item: PartialOrd<I::Item>,
2126 Self: Sized,
2127 {
2128 match self {
2129 Self::I0(this) => this.gt(other),
2130 Self::I1(this) => this.gt(other),
2131 Self::I2(this) => this.gt(other),
2132 Self::I3(this) => this.gt(other),
2133 Self::I4(this) => this.gt(other),
2134 }
2135 }
2136 fn ge<I>(self, other: I) -> bool
2137 where
2138 I: IntoIterator,
2139 Self::Item: PartialOrd<I::Item>,
2140 Self: Sized,
2141 {
2142 match self {
2143 Self::I0(this) => this.ge(other),
2144 Self::I1(this) => this.ge(other),
2145 Self::I2(this) => this.ge(other),
2146 Self::I3(this) => this.ge(other),
2147 Self::I4(this) => this.ge(other),
2148 }
2149 }
2150 }
2151 impl<Item, I0, I1, I2, I3, I4> DoubleEndedIterator for Iter5<I0, I1, I2, I3, I4>
2152 where
2153 I0: DoubleEndedIterator<Item = Item>,
2154 I1: DoubleEndedIterator<Item = Item>,
2155 I2: DoubleEndedIterator<Item = Item>,
2156 I3: DoubleEndedIterator<Item = Item>,
2157 I4: DoubleEndedIterator<Item = Item>,
2158 {
2159 fn next_back(&mut self) -> Option<Self::Item> {
2160 match self {
2161 Self::I0(this) => this.next_back(),
2162 Self::I1(this) => this.next_back(),
2163 Self::I2(this) => this.next_back(),
2164 Self::I3(this) => this.next_back(),
2165 Self::I4(this) => this.next_back(),
2166 }
2167 }
2168 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
2169 match self {
2170 Self::I0(this) => this.nth_back(n),
2171 Self::I1(this) => this.nth_back(n),
2172 Self::I2(this) => this.nth_back(n),
2173 Self::I3(this) => this.nth_back(n),
2174 Self::I4(this) => this.nth_back(n),
2175 }
2176 }
2177 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
2178 where
2179 P: FnMut(&Self::Item) -> bool,
2180 {
2181 match self {
2182 Self::I0(this) => this.rfind(predicate),
2183 Self::I1(this) => this.rfind(predicate),
2184 Self::I2(this) => this.rfind(predicate),
2185 Self::I3(this) => this.rfind(predicate),
2186 Self::I4(this) => this.rfind(predicate),
2187 }
2188 }
2189 fn rfold<B, F>(self, init: B, f: F) -> B
2190 where
2191 Self: Sized,
2192 F: FnMut(B, Self::Item) -> B,
2193 {
2194 match self {
2195 Self::I0(this) => this.rfold(init, f),
2196 Self::I1(this) => this.rfold(init, f),
2197 Self::I2(this) => this.rfold(init, f),
2198 Self::I3(this) => this.rfold(init, f),
2199 Self::I4(this) => this.rfold(init, f),
2200 }
2201 }
2202 }
2203 impl<Item, I0, I1, I2, I3, I4> ExactSizeIterator for Iter5<I0, I1, I2, I3, I4>
2204 where
2205 I0: ExactSizeIterator<Item = Item>,
2206 I1: ExactSizeIterator<Item = Item>,
2207 I2: ExactSizeIterator<Item = Item>,
2208 I3: ExactSizeIterator<Item = Item>,
2209 I4: ExactSizeIterator<Item = Item>,
2210 {
2211 fn len(&self) -> usize {
2212 match self {
2213 Self::I0(this) => this.len(),
2214 Self::I1(this) => this.len(),
2215 Self::I2(this) => this.len(),
2216 Self::I3(this) => this.len(),
2217 Self::I4(this) => this.len(),
2218 }
2219 }
2220 }
2221 impl<Item, I0, I1, I2, I3, I4> FusedIterator for Iter5<I0, I1, I2, I3, I4>
2222 where
2223 I0: FusedIterator<Item = Item>,
2224 I1: FusedIterator<Item = Item>,
2225 I2: FusedIterator<Item = Item>,
2226 I3: FusedIterator<Item = Item>,
2227 I4: FusedIterator<Item = Item>,
2228 {
2229 }
2230}
2231pub mod iter6 {
2232 use super::*;
2233 use core::iter::FusedIterator;
2234 #[derive(Debug, Clone, Copy)]
2235 pub enum Iter6<I0, I1, I2, I3, I4, I5> {
2236 I0(I0),
2237 I1(I1),
2238 I2(I2),
2239 I3(I3),
2240 I4(I4),
2241 I5(I5),
2242 }
2243 pub trait IntoIter0: IntoIterator {
2244 #[allow(clippy::type_complexity)]
2245 fn into_iter0<I1, I2, I3, I4, I5>(self) -> Iter6<Self::IntoIter, I1, I2, I3, I4, I5>;
2246 }
2247 impl<T: IntoIterator> IntoIter0 for T {
2248 #[allow(clippy::type_complexity)]
2249 fn into_iter0<I1, I2, I3, I4, I5>(self) -> Iter6<Self::IntoIter, I1, I2, I3, I4, I5> {
2250 Iter6::I0(self.into_iter())
2251 }
2252 }
2253 pub trait IntoIter1: IntoIterator {
2254 #[allow(clippy::type_complexity)]
2255 fn into_iter1<I0, I2, I3, I4, I5>(self) -> Iter6<I0, Self::IntoIter, I2, I3, I4, I5>;
2256 }
2257 impl<T: IntoIterator> IntoIter1 for T {
2258 #[allow(clippy::type_complexity)]
2259 fn into_iter1<I0, I2, I3, I4, I5>(self) -> Iter6<I0, Self::IntoIter, I2, I3, I4, I5> {
2260 Iter6::I1(self.into_iter())
2261 }
2262 }
2263 pub trait IntoIter2: IntoIterator {
2264 #[allow(clippy::type_complexity)]
2265 fn into_iter2<I0, I1, I3, I4, I5>(self) -> Iter6<I0, I1, Self::IntoIter, I3, I4, I5>;
2266 }
2267 impl<T: IntoIterator> IntoIter2 for T {
2268 #[allow(clippy::type_complexity)]
2269 fn into_iter2<I0, I1, I3, I4, I5>(self) -> Iter6<I0, I1, Self::IntoIter, I3, I4, I5> {
2270 Iter6::I2(self.into_iter())
2271 }
2272 }
2273 pub trait IntoIter3: IntoIterator {
2274 #[allow(clippy::type_complexity)]
2275 fn into_iter3<I0, I1, I2, I4, I5>(self) -> Iter6<I0, I1, I2, Self::IntoIter, I4, I5>;
2276 }
2277 impl<T: IntoIterator> IntoIter3 for T {
2278 #[allow(clippy::type_complexity)]
2279 fn into_iter3<I0, I1, I2, I4, I5>(self) -> Iter6<I0, I1, I2, Self::IntoIter, I4, I5> {
2280 Iter6::I3(self.into_iter())
2281 }
2282 }
2283 pub trait IntoIter4: IntoIterator {
2284 #[allow(clippy::type_complexity)]
2285 fn into_iter4<I0, I1, I2, I3, I5>(self) -> Iter6<I0, I1, I2, I3, Self::IntoIter, I5>;
2286 }
2287 impl<T: IntoIterator> IntoIter4 for T {
2288 #[allow(clippy::type_complexity)]
2289 fn into_iter4<I0, I1, I2, I3, I5>(self) -> Iter6<I0, I1, I2, I3, Self::IntoIter, I5> {
2290 Iter6::I4(self.into_iter())
2291 }
2292 }
2293 pub trait IntoIter5: IntoIterator {
2294 #[allow(clippy::type_complexity)]
2295 fn into_iter5<I0, I1, I2, I3, I4>(self) -> Iter6<I0, I1, I2, I3, I4, Self::IntoIter>;
2296 }
2297 impl<T: IntoIterator> IntoIter5 for T {
2298 #[allow(clippy::type_complexity)]
2299 fn into_iter5<I0, I1, I2, I3, I4>(self) -> Iter6<I0, I1, I2, I3, I4, Self::IntoIter> {
2300 Iter6::I5(self.into_iter())
2301 }
2302 }
2303 impl<Item, I0, I1, I2, I3, I4, I5> Iterator for Iter6<I0, I1, I2, I3, I4, I5>
2304 where
2305 I0: Iterator<Item = Item>,
2306 I1: Iterator<Item = Item>,
2307 I2: Iterator<Item = Item>,
2308 I3: Iterator<Item = Item>,
2309 I4: Iterator<Item = Item>,
2310 I5: Iterator<Item = Item>,
2311 {
2312 type Item = Item;
2313 fn next(&mut self) -> Option<Self::Item> {
2314 match self {
2315 Self::I0(this) => this.next(),
2316 Self::I1(this) => this.next(),
2317 Self::I2(this) => this.next(),
2318 Self::I3(this) => this.next(),
2319 Self::I4(this) => this.next(),
2320 Self::I5(this) => this.next(),
2321 }
2322 }
2323 fn size_hint(&self) -> (usize, Option<usize>) {
2324 match self {
2325 Self::I0(this) => this.size_hint(),
2326 Self::I1(this) => this.size_hint(),
2327 Self::I2(this) => this.size_hint(),
2328 Self::I3(this) => this.size_hint(),
2329 Self::I4(this) => this.size_hint(),
2330 Self::I5(this) => this.size_hint(),
2331 }
2332 }
2333 fn count(self) -> usize
2334 where
2335 Self: Sized,
2336 {
2337 match self {
2338 Self::I0(this) => this.count(),
2339 Self::I1(this) => this.count(),
2340 Self::I2(this) => this.count(),
2341 Self::I3(this) => this.count(),
2342 Self::I4(this) => this.count(),
2343 Self::I5(this) => this.count(),
2344 }
2345 }
2346 fn last(self) -> Option<Self::Item>
2347 where
2348 Self: Sized,
2349 {
2350 match self {
2351 Self::I0(this) => this.last(),
2352 Self::I1(this) => this.last(),
2353 Self::I2(this) => this.last(),
2354 Self::I3(this) => this.last(),
2355 Self::I4(this) => this.last(),
2356 Self::I5(this) => this.last(),
2357 }
2358 }
2359 fn nth(&mut self, n: usize) -> Option<Self::Item> {
2360 match self {
2361 Self::I0(this) => this.nth(n),
2362 Self::I1(this) => this.nth(n),
2363 Self::I2(this) => this.nth(n),
2364 Self::I3(this) => this.nth(n),
2365 Self::I4(this) => this.nth(n),
2366 Self::I5(this) => this.nth(n),
2367 }
2368 }
2369 fn for_each<F>(self, f: F)
2370 where
2371 Self: Sized,
2372 F: FnMut(Self::Item),
2373 {
2374 match self {
2375 Self::I0(this) => this.for_each(f),
2376 Self::I1(this) => this.for_each(f),
2377 Self::I2(this) => this.for_each(f),
2378 Self::I3(this) => this.for_each(f),
2379 Self::I4(this) => this.for_each(f),
2380 Self::I5(this) => this.for_each(f),
2381 }
2382 }
2383 fn collect<B: FromIterator<Self::Item>>(self) -> B
2384 where
2385 Self: Sized,
2386 {
2387 match self {
2388 Self::I0(this) => this.collect(),
2389 Self::I1(this) => this.collect(),
2390 Self::I2(this) => this.collect(),
2391 Self::I3(this) => this.collect(),
2392 Self::I4(this) => this.collect(),
2393 Self::I5(this) => this.collect(),
2394 }
2395 }
2396 fn partition<B, F>(self, f: F) -> (B, B)
2397 where
2398 Self: Sized,
2399 B: Default + Extend<Self::Item>,
2400 F: FnMut(&Self::Item) -> bool,
2401 {
2402 match self {
2403 Self::I0(this) => this.partition(f),
2404 Self::I1(this) => this.partition(f),
2405 Self::I2(this) => this.partition(f),
2406 Self::I3(this) => this.partition(f),
2407 Self::I4(this) => this.partition(f),
2408 Self::I5(this) => this.partition(f),
2409 }
2410 }
2411 fn fold<B, F>(self, init: B, f: F) -> B
2412 where
2413 Self: Sized,
2414 F: FnMut(B, Self::Item) -> B,
2415 {
2416 match self {
2417 Self::I0(this) => this.fold(init, f),
2418 Self::I1(this) => this.fold(init, f),
2419 Self::I2(this) => this.fold(init, f),
2420 Self::I3(this) => this.fold(init, f),
2421 Self::I4(this) => this.fold(init, f),
2422 Self::I5(this) => this.fold(init, f),
2423 }
2424 }
2425 fn reduce<F>(self, f: F) -> Option<Self::Item>
2426 where
2427 Self: Sized,
2428 F: FnMut(Self::Item, Self::Item) -> Self::Item,
2429 {
2430 match self {
2431 Self::I0(this) => this.reduce(f),
2432 Self::I1(this) => this.reduce(f),
2433 Self::I2(this) => this.reduce(f),
2434 Self::I3(this) => this.reduce(f),
2435 Self::I4(this) => this.reduce(f),
2436 Self::I5(this) => this.reduce(f),
2437 }
2438 }
2439 fn all<F>(&mut self, f: F) -> bool
2440 where
2441 Self: Sized,
2442 F: FnMut(Self::Item) -> bool,
2443 {
2444 match self {
2445 Self::I0(this) => this.all(f),
2446 Self::I1(this) => this.all(f),
2447 Self::I2(this) => this.all(f),
2448 Self::I3(this) => this.all(f),
2449 Self::I4(this) => this.all(f),
2450 Self::I5(this) => this.all(f),
2451 }
2452 }
2453 fn any<F>(&mut self, f: F) -> bool
2454 where
2455 Self: Sized,
2456 F: FnMut(Self::Item) -> bool,
2457 {
2458 match self {
2459 Self::I0(this) => this.any(f),
2460 Self::I1(this) => this.any(f),
2461 Self::I2(this) => this.any(f),
2462 Self::I3(this) => this.any(f),
2463 Self::I4(this) => this.any(f),
2464 Self::I5(this) => this.any(f),
2465 }
2466 }
2467 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
2468 where
2469 Self: Sized,
2470 P: FnMut(&Self::Item) -> bool,
2471 {
2472 match self {
2473 Self::I0(this) => this.find(predicate),
2474 Self::I1(this) => this.find(predicate),
2475 Self::I2(this) => this.find(predicate),
2476 Self::I3(this) => this.find(predicate),
2477 Self::I4(this) => this.find(predicate),
2478 Self::I5(this) => this.find(predicate),
2479 }
2480 }
2481 fn find_map<B, F>(&mut self, f: F) -> Option<B>
2482 where
2483 Self: Sized,
2484 F: FnMut(Self::Item) -> Option<B>,
2485 {
2486 match self {
2487 Self::I0(this) => this.find_map(f),
2488 Self::I1(this) => this.find_map(f),
2489 Self::I2(this) => this.find_map(f),
2490 Self::I3(this) => this.find_map(f),
2491 Self::I4(this) => this.find_map(f),
2492 Self::I5(this) => this.find_map(f),
2493 }
2494 }
2495 fn position<P>(&mut self, predicate: P) -> Option<usize>
2496 where
2497 Self: Sized,
2498 P: FnMut(Self::Item) -> bool,
2499 {
2500 match self {
2501 Self::I0(this) => this.position(predicate),
2502 Self::I1(this) => this.position(predicate),
2503 Self::I2(this) => this.position(predicate),
2504 Self::I3(this) => this.position(predicate),
2505 Self::I4(this) => this.position(predicate),
2506 Self::I5(this) => this.position(predicate),
2507 }
2508 }
2509 fn max(self) -> Option<Self::Item>
2510 where
2511 Self: Sized,
2512 Self::Item: Ord,
2513 {
2514 match self {
2515 Self::I0(this) => this.max(),
2516 Self::I1(this) => this.max(),
2517 Self::I2(this) => this.max(),
2518 Self::I3(this) => this.max(),
2519 Self::I4(this) => this.max(),
2520 Self::I5(this) => this.max(),
2521 }
2522 }
2523 fn min(self) -> Option<Self::Item>
2524 where
2525 Self: Sized,
2526 Self::Item: Ord,
2527 {
2528 match self {
2529 Self::I0(this) => this.min(),
2530 Self::I1(this) => this.min(),
2531 Self::I2(this) => this.min(),
2532 Self::I3(this) => this.min(),
2533 Self::I4(this) => this.min(),
2534 Self::I5(this) => this.min(),
2535 }
2536 }
2537 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
2538 where
2539 Self: Sized,
2540 F: FnMut(&Self::Item) -> B,
2541 {
2542 match self {
2543 Self::I0(this) => this.max_by_key(f),
2544 Self::I1(this) => this.max_by_key(f),
2545 Self::I2(this) => this.max_by_key(f),
2546 Self::I3(this) => this.max_by_key(f),
2547 Self::I4(this) => this.max_by_key(f),
2548 Self::I5(this) => this.max_by_key(f),
2549 }
2550 }
2551 fn max_by<F>(self, compare: F) -> Option<Self::Item>
2552 where
2553 Self: Sized,
2554 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
2555 {
2556 match self {
2557 Self::I0(this) => this.max_by(compare),
2558 Self::I1(this) => this.max_by(compare),
2559 Self::I2(this) => this.max_by(compare),
2560 Self::I3(this) => this.max_by(compare),
2561 Self::I4(this) => this.max_by(compare),
2562 Self::I5(this) => this.max_by(compare),
2563 }
2564 }
2565 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
2566 where
2567 Self: Sized,
2568 F: FnMut(&Self::Item) -> B,
2569 {
2570 match self {
2571 Self::I0(this) => this.min_by_key(f),
2572 Self::I1(this) => this.min_by_key(f),
2573 Self::I2(this) => this.min_by_key(f),
2574 Self::I3(this) => this.min_by_key(f),
2575 Self::I4(this) => this.min_by_key(f),
2576 Self::I5(this) => this.min_by_key(f),
2577 }
2578 }
2579 fn min_by<F>(self, compare: F) -> Option<Self::Item>
2580 where
2581 Self: Sized,
2582 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
2583 {
2584 match self {
2585 Self::I0(this) => this.min_by(compare),
2586 Self::I1(this) => this.min_by(compare),
2587 Self::I2(this) => this.min_by(compare),
2588 Self::I3(this) => this.min_by(compare),
2589 Self::I4(this) => this.min_by(compare),
2590 Self::I5(this) => this.min_by(compare),
2591 }
2592 }
2593 fn sum<S>(self) -> S
2594 where
2595 Self: Sized,
2596 S: Sum<Self::Item>,
2597 {
2598 match self {
2599 Self::I0(this) => this.sum(),
2600 Self::I1(this) => this.sum(),
2601 Self::I2(this) => this.sum(),
2602 Self::I3(this) => this.sum(),
2603 Self::I4(this) => this.sum(),
2604 Self::I5(this) => this.sum(),
2605 }
2606 }
2607 fn product<P>(self) -> P
2608 where
2609 Self: Sized,
2610 P: Product<Self::Item>,
2611 {
2612 match self {
2613 Self::I0(this) => this.product(),
2614 Self::I1(this) => this.product(),
2615 Self::I2(this) => this.product(),
2616 Self::I3(this) => this.product(),
2617 Self::I4(this) => this.product(),
2618 Self::I5(this) => this.product(),
2619 }
2620 }
2621 fn cmp<I>(self, other: I) -> Ordering
2622 where
2623 I: IntoIterator<Item = Self::Item>,
2624 Self::Item: Ord,
2625 Self: Sized,
2626 {
2627 match self {
2628 Self::I0(this) => this.cmp(other),
2629 Self::I1(this) => this.cmp(other),
2630 Self::I2(this) => this.cmp(other),
2631 Self::I3(this) => this.cmp(other),
2632 Self::I4(this) => this.cmp(other),
2633 Self::I5(this) => this.cmp(other),
2634 }
2635 }
2636 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
2637 where
2638 I: IntoIterator,
2639 Self::Item: PartialOrd<I::Item>,
2640 Self: Sized,
2641 {
2642 match self {
2643 Self::I0(this) => this.partial_cmp(other),
2644 Self::I1(this) => this.partial_cmp(other),
2645 Self::I2(this) => this.partial_cmp(other),
2646 Self::I3(this) => this.partial_cmp(other),
2647 Self::I4(this) => this.partial_cmp(other),
2648 Self::I5(this) => this.partial_cmp(other),
2649 }
2650 }
2651 fn eq<I>(self, other: I) -> bool
2652 where
2653 I: IntoIterator,
2654 Self::Item: PartialEq<I::Item>,
2655 Self: Sized,
2656 {
2657 match self {
2658 Self::I0(this) => this.eq(other),
2659 Self::I1(this) => this.eq(other),
2660 Self::I2(this) => this.eq(other),
2661 Self::I3(this) => this.eq(other),
2662 Self::I4(this) => this.eq(other),
2663 Self::I5(this) => this.eq(other),
2664 }
2665 }
2666 fn ne<I>(self, other: I) -> bool
2667 where
2668 I: IntoIterator,
2669 Self::Item: PartialEq<I::Item>,
2670 Self: Sized,
2671 {
2672 match self {
2673 Self::I0(this) => this.ne(other),
2674 Self::I1(this) => this.ne(other),
2675 Self::I2(this) => this.ne(other),
2676 Self::I3(this) => this.ne(other),
2677 Self::I4(this) => this.ne(other),
2678 Self::I5(this) => this.ne(other),
2679 }
2680 }
2681 fn lt<I>(self, other: I) -> bool
2682 where
2683 I: IntoIterator,
2684 Self::Item: PartialOrd<I::Item>,
2685 Self: Sized,
2686 {
2687 match self {
2688 Self::I0(this) => this.lt(other),
2689 Self::I1(this) => this.lt(other),
2690 Self::I2(this) => this.lt(other),
2691 Self::I3(this) => this.lt(other),
2692 Self::I4(this) => this.lt(other),
2693 Self::I5(this) => this.lt(other),
2694 }
2695 }
2696 fn le<I>(self, other: I) -> bool
2697 where
2698 I: IntoIterator,
2699 Self::Item: PartialOrd<I::Item>,
2700 Self: Sized,
2701 {
2702 match self {
2703 Self::I0(this) => this.le(other),
2704 Self::I1(this) => this.le(other),
2705 Self::I2(this) => this.le(other),
2706 Self::I3(this) => this.le(other),
2707 Self::I4(this) => this.le(other),
2708 Self::I5(this) => this.le(other),
2709 }
2710 }
2711 fn gt<I>(self, other: I) -> bool
2712 where
2713 I: IntoIterator,
2714 Self::Item: PartialOrd<I::Item>,
2715 Self: Sized,
2716 {
2717 match self {
2718 Self::I0(this) => this.gt(other),
2719 Self::I1(this) => this.gt(other),
2720 Self::I2(this) => this.gt(other),
2721 Self::I3(this) => this.gt(other),
2722 Self::I4(this) => this.gt(other),
2723 Self::I5(this) => this.gt(other),
2724 }
2725 }
2726 fn ge<I>(self, other: I) -> bool
2727 where
2728 I: IntoIterator,
2729 Self::Item: PartialOrd<I::Item>,
2730 Self: Sized,
2731 {
2732 match self {
2733 Self::I0(this) => this.ge(other),
2734 Self::I1(this) => this.ge(other),
2735 Self::I2(this) => this.ge(other),
2736 Self::I3(this) => this.ge(other),
2737 Self::I4(this) => this.ge(other),
2738 Self::I5(this) => this.ge(other),
2739 }
2740 }
2741 }
2742 impl<Item, I0, I1, I2, I3, I4, I5> DoubleEndedIterator for Iter6<I0, I1, I2, I3, I4, I5>
2743 where
2744 I0: DoubleEndedIterator<Item = Item>,
2745 I1: DoubleEndedIterator<Item = Item>,
2746 I2: DoubleEndedIterator<Item = Item>,
2747 I3: DoubleEndedIterator<Item = Item>,
2748 I4: DoubleEndedIterator<Item = Item>,
2749 I5: DoubleEndedIterator<Item = Item>,
2750 {
2751 fn next_back(&mut self) -> Option<Self::Item> {
2752 match self {
2753 Self::I0(this) => this.next_back(),
2754 Self::I1(this) => this.next_back(),
2755 Self::I2(this) => this.next_back(),
2756 Self::I3(this) => this.next_back(),
2757 Self::I4(this) => this.next_back(),
2758 Self::I5(this) => this.next_back(),
2759 }
2760 }
2761 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
2762 match self {
2763 Self::I0(this) => this.nth_back(n),
2764 Self::I1(this) => this.nth_back(n),
2765 Self::I2(this) => this.nth_back(n),
2766 Self::I3(this) => this.nth_back(n),
2767 Self::I4(this) => this.nth_back(n),
2768 Self::I5(this) => this.nth_back(n),
2769 }
2770 }
2771 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
2772 where
2773 P: FnMut(&Self::Item) -> bool,
2774 {
2775 match self {
2776 Self::I0(this) => this.rfind(predicate),
2777 Self::I1(this) => this.rfind(predicate),
2778 Self::I2(this) => this.rfind(predicate),
2779 Self::I3(this) => this.rfind(predicate),
2780 Self::I4(this) => this.rfind(predicate),
2781 Self::I5(this) => this.rfind(predicate),
2782 }
2783 }
2784 fn rfold<B, F>(self, init: B, f: F) -> B
2785 where
2786 Self: Sized,
2787 F: FnMut(B, Self::Item) -> B,
2788 {
2789 match self {
2790 Self::I0(this) => this.rfold(init, f),
2791 Self::I1(this) => this.rfold(init, f),
2792 Self::I2(this) => this.rfold(init, f),
2793 Self::I3(this) => this.rfold(init, f),
2794 Self::I4(this) => this.rfold(init, f),
2795 Self::I5(this) => this.rfold(init, f),
2796 }
2797 }
2798 }
2799 impl<Item, I0, I1, I2, I3, I4, I5> ExactSizeIterator for Iter6<I0, I1, I2, I3, I4, I5>
2800 where
2801 I0: ExactSizeIterator<Item = Item>,
2802 I1: ExactSizeIterator<Item = Item>,
2803 I2: ExactSizeIterator<Item = Item>,
2804 I3: ExactSizeIterator<Item = Item>,
2805 I4: ExactSizeIterator<Item = Item>,
2806 I5: ExactSizeIterator<Item = Item>,
2807 {
2808 fn len(&self) -> usize {
2809 match self {
2810 Self::I0(this) => this.len(),
2811 Self::I1(this) => this.len(),
2812 Self::I2(this) => this.len(),
2813 Self::I3(this) => this.len(),
2814 Self::I4(this) => this.len(),
2815 Self::I5(this) => this.len(),
2816 }
2817 }
2818 }
2819 impl<Item, I0, I1, I2, I3, I4, I5> FusedIterator for Iter6<I0, I1, I2, I3, I4, I5>
2820 where
2821 I0: FusedIterator<Item = Item>,
2822 I1: FusedIterator<Item = Item>,
2823 I2: FusedIterator<Item = Item>,
2824 I3: FusedIterator<Item = Item>,
2825 I4: FusedIterator<Item = Item>,
2826 I5: FusedIterator<Item = Item>,
2827 {
2828 }
2829}
2830pub mod iter7 {
2831 use super::*;
2832 use core::iter::FusedIterator;
2833 #[derive(Debug, Clone, Copy)]
2834 pub enum Iter7<I0, I1, I2, I3, I4, I5, I6> {
2835 I0(I0),
2836 I1(I1),
2837 I2(I2),
2838 I3(I3),
2839 I4(I4),
2840 I5(I5),
2841 I6(I6),
2842 }
2843 pub trait IntoIter0: IntoIterator {
2844 #[allow(clippy::type_complexity)]
2845 fn into_iter0<I1, I2, I3, I4, I5, I6>(
2846 self,
2847 ) -> Iter7<Self::IntoIter, I1, I2, I3, I4, I5, I6>;
2848 }
2849 impl<T: IntoIterator> IntoIter0 for T {
2850 #[allow(clippy::type_complexity)]
2851 fn into_iter0<I1, I2, I3, I4, I5, I6>(
2852 self,
2853 ) -> Iter7<Self::IntoIter, I1, I2, I3, I4, I5, I6> {
2854 Iter7::I0(self.into_iter())
2855 }
2856 }
2857 pub trait IntoIter1: IntoIterator {
2858 #[allow(clippy::type_complexity)]
2859 fn into_iter1<I0, I2, I3, I4, I5, I6>(
2860 self,
2861 ) -> Iter7<I0, Self::IntoIter, I2, I3, I4, I5, I6>;
2862 }
2863 impl<T: IntoIterator> IntoIter1 for T {
2864 #[allow(clippy::type_complexity)]
2865 fn into_iter1<I0, I2, I3, I4, I5, I6>(
2866 self,
2867 ) -> Iter7<I0, Self::IntoIter, I2, I3, I4, I5, I6> {
2868 Iter7::I1(self.into_iter())
2869 }
2870 }
2871 pub trait IntoIter2: IntoIterator {
2872 #[allow(clippy::type_complexity)]
2873 fn into_iter2<I0, I1, I3, I4, I5, I6>(
2874 self,
2875 ) -> Iter7<I0, I1, Self::IntoIter, I3, I4, I5, I6>;
2876 }
2877 impl<T: IntoIterator> IntoIter2 for T {
2878 #[allow(clippy::type_complexity)]
2879 fn into_iter2<I0, I1, I3, I4, I5, I6>(
2880 self,
2881 ) -> Iter7<I0, I1, Self::IntoIter, I3, I4, I5, I6> {
2882 Iter7::I2(self.into_iter())
2883 }
2884 }
2885 pub trait IntoIter3: IntoIterator {
2886 #[allow(clippy::type_complexity)]
2887 fn into_iter3<I0, I1, I2, I4, I5, I6>(
2888 self,
2889 ) -> Iter7<I0, I1, I2, Self::IntoIter, I4, I5, I6>;
2890 }
2891 impl<T: IntoIterator> IntoIter3 for T {
2892 #[allow(clippy::type_complexity)]
2893 fn into_iter3<I0, I1, I2, I4, I5, I6>(
2894 self,
2895 ) -> Iter7<I0, I1, I2, Self::IntoIter, I4, I5, I6> {
2896 Iter7::I3(self.into_iter())
2897 }
2898 }
2899 pub trait IntoIter4: IntoIterator {
2900 #[allow(clippy::type_complexity)]
2901 fn into_iter4<I0, I1, I2, I3, I5, I6>(
2902 self,
2903 ) -> Iter7<I0, I1, I2, I3, Self::IntoIter, I5, I6>;
2904 }
2905 impl<T: IntoIterator> IntoIter4 for T {
2906 #[allow(clippy::type_complexity)]
2907 fn into_iter4<I0, I1, I2, I3, I5, I6>(
2908 self,
2909 ) -> Iter7<I0, I1, I2, I3, Self::IntoIter, I5, I6> {
2910 Iter7::I4(self.into_iter())
2911 }
2912 }
2913 pub trait IntoIter5: IntoIterator {
2914 #[allow(clippy::type_complexity)]
2915 fn into_iter5<I0, I1, I2, I3, I4, I6>(
2916 self,
2917 ) -> Iter7<I0, I1, I2, I3, I4, Self::IntoIter, I6>;
2918 }
2919 impl<T: IntoIterator> IntoIter5 for T {
2920 #[allow(clippy::type_complexity)]
2921 fn into_iter5<I0, I1, I2, I3, I4, I6>(
2922 self,
2923 ) -> Iter7<I0, I1, I2, I3, I4, Self::IntoIter, I6> {
2924 Iter7::I5(self.into_iter())
2925 }
2926 }
2927 pub trait IntoIter6: IntoIterator {
2928 #[allow(clippy::type_complexity)]
2929 fn into_iter6<I0, I1, I2, I3, I4, I5>(
2930 self,
2931 ) -> Iter7<I0, I1, I2, I3, I4, I5, Self::IntoIter>;
2932 }
2933 impl<T: IntoIterator> IntoIter6 for T {
2934 #[allow(clippy::type_complexity)]
2935 fn into_iter6<I0, I1, I2, I3, I4, I5>(
2936 self,
2937 ) -> Iter7<I0, I1, I2, I3, I4, I5, Self::IntoIter> {
2938 Iter7::I6(self.into_iter())
2939 }
2940 }
2941 impl<Item, I0, I1, I2, I3, I4, I5, I6> Iterator for Iter7<I0, I1, I2, I3, I4, I5, I6>
2942 where
2943 I0: Iterator<Item = Item>,
2944 I1: Iterator<Item = Item>,
2945 I2: Iterator<Item = Item>,
2946 I3: Iterator<Item = Item>,
2947 I4: Iterator<Item = Item>,
2948 I5: Iterator<Item = Item>,
2949 I6: Iterator<Item = Item>,
2950 {
2951 type Item = Item;
2952 fn next(&mut self) -> Option<Self::Item> {
2953 match self {
2954 Self::I0(this) => this.next(),
2955 Self::I1(this) => this.next(),
2956 Self::I2(this) => this.next(),
2957 Self::I3(this) => this.next(),
2958 Self::I4(this) => this.next(),
2959 Self::I5(this) => this.next(),
2960 Self::I6(this) => this.next(),
2961 }
2962 }
2963 fn size_hint(&self) -> (usize, Option<usize>) {
2964 match self {
2965 Self::I0(this) => this.size_hint(),
2966 Self::I1(this) => this.size_hint(),
2967 Self::I2(this) => this.size_hint(),
2968 Self::I3(this) => this.size_hint(),
2969 Self::I4(this) => this.size_hint(),
2970 Self::I5(this) => this.size_hint(),
2971 Self::I6(this) => this.size_hint(),
2972 }
2973 }
2974 fn count(self) -> usize
2975 where
2976 Self: Sized,
2977 {
2978 match self {
2979 Self::I0(this) => this.count(),
2980 Self::I1(this) => this.count(),
2981 Self::I2(this) => this.count(),
2982 Self::I3(this) => this.count(),
2983 Self::I4(this) => this.count(),
2984 Self::I5(this) => this.count(),
2985 Self::I6(this) => this.count(),
2986 }
2987 }
2988 fn last(self) -> Option<Self::Item>
2989 where
2990 Self: Sized,
2991 {
2992 match self {
2993 Self::I0(this) => this.last(),
2994 Self::I1(this) => this.last(),
2995 Self::I2(this) => this.last(),
2996 Self::I3(this) => this.last(),
2997 Self::I4(this) => this.last(),
2998 Self::I5(this) => this.last(),
2999 Self::I6(this) => this.last(),
3000 }
3001 }
3002 fn nth(&mut self, n: usize) -> Option<Self::Item> {
3003 match self {
3004 Self::I0(this) => this.nth(n),
3005 Self::I1(this) => this.nth(n),
3006 Self::I2(this) => this.nth(n),
3007 Self::I3(this) => this.nth(n),
3008 Self::I4(this) => this.nth(n),
3009 Self::I5(this) => this.nth(n),
3010 Self::I6(this) => this.nth(n),
3011 }
3012 }
3013 fn for_each<F>(self, f: F)
3014 where
3015 Self: Sized,
3016 F: FnMut(Self::Item),
3017 {
3018 match self {
3019 Self::I0(this) => this.for_each(f),
3020 Self::I1(this) => this.for_each(f),
3021 Self::I2(this) => this.for_each(f),
3022 Self::I3(this) => this.for_each(f),
3023 Self::I4(this) => this.for_each(f),
3024 Self::I5(this) => this.for_each(f),
3025 Self::I6(this) => this.for_each(f),
3026 }
3027 }
3028 fn collect<B: FromIterator<Self::Item>>(self) -> B
3029 where
3030 Self: Sized,
3031 {
3032 match self {
3033 Self::I0(this) => this.collect(),
3034 Self::I1(this) => this.collect(),
3035 Self::I2(this) => this.collect(),
3036 Self::I3(this) => this.collect(),
3037 Self::I4(this) => this.collect(),
3038 Self::I5(this) => this.collect(),
3039 Self::I6(this) => this.collect(),
3040 }
3041 }
3042 fn partition<B, F>(self, f: F) -> (B, B)
3043 where
3044 Self: Sized,
3045 B: Default + Extend<Self::Item>,
3046 F: FnMut(&Self::Item) -> bool,
3047 {
3048 match self {
3049 Self::I0(this) => this.partition(f),
3050 Self::I1(this) => this.partition(f),
3051 Self::I2(this) => this.partition(f),
3052 Self::I3(this) => this.partition(f),
3053 Self::I4(this) => this.partition(f),
3054 Self::I5(this) => this.partition(f),
3055 Self::I6(this) => this.partition(f),
3056 }
3057 }
3058 fn fold<B, F>(self, init: B, f: F) -> B
3059 where
3060 Self: Sized,
3061 F: FnMut(B, Self::Item) -> B,
3062 {
3063 match self {
3064 Self::I0(this) => this.fold(init, f),
3065 Self::I1(this) => this.fold(init, f),
3066 Self::I2(this) => this.fold(init, f),
3067 Self::I3(this) => this.fold(init, f),
3068 Self::I4(this) => this.fold(init, f),
3069 Self::I5(this) => this.fold(init, f),
3070 Self::I6(this) => this.fold(init, f),
3071 }
3072 }
3073 fn reduce<F>(self, f: F) -> Option<Self::Item>
3074 where
3075 Self: Sized,
3076 F: FnMut(Self::Item, Self::Item) -> Self::Item,
3077 {
3078 match self {
3079 Self::I0(this) => this.reduce(f),
3080 Self::I1(this) => this.reduce(f),
3081 Self::I2(this) => this.reduce(f),
3082 Self::I3(this) => this.reduce(f),
3083 Self::I4(this) => this.reduce(f),
3084 Self::I5(this) => this.reduce(f),
3085 Self::I6(this) => this.reduce(f),
3086 }
3087 }
3088 fn all<F>(&mut self, f: F) -> bool
3089 where
3090 Self: Sized,
3091 F: FnMut(Self::Item) -> bool,
3092 {
3093 match self {
3094 Self::I0(this) => this.all(f),
3095 Self::I1(this) => this.all(f),
3096 Self::I2(this) => this.all(f),
3097 Self::I3(this) => this.all(f),
3098 Self::I4(this) => this.all(f),
3099 Self::I5(this) => this.all(f),
3100 Self::I6(this) => this.all(f),
3101 }
3102 }
3103 fn any<F>(&mut self, f: F) -> bool
3104 where
3105 Self: Sized,
3106 F: FnMut(Self::Item) -> bool,
3107 {
3108 match self {
3109 Self::I0(this) => this.any(f),
3110 Self::I1(this) => this.any(f),
3111 Self::I2(this) => this.any(f),
3112 Self::I3(this) => this.any(f),
3113 Self::I4(this) => this.any(f),
3114 Self::I5(this) => this.any(f),
3115 Self::I6(this) => this.any(f),
3116 }
3117 }
3118 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
3119 where
3120 Self: Sized,
3121 P: FnMut(&Self::Item) -> bool,
3122 {
3123 match self {
3124 Self::I0(this) => this.find(predicate),
3125 Self::I1(this) => this.find(predicate),
3126 Self::I2(this) => this.find(predicate),
3127 Self::I3(this) => this.find(predicate),
3128 Self::I4(this) => this.find(predicate),
3129 Self::I5(this) => this.find(predicate),
3130 Self::I6(this) => this.find(predicate),
3131 }
3132 }
3133 fn find_map<B, F>(&mut self, f: F) -> Option<B>
3134 where
3135 Self: Sized,
3136 F: FnMut(Self::Item) -> Option<B>,
3137 {
3138 match self {
3139 Self::I0(this) => this.find_map(f),
3140 Self::I1(this) => this.find_map(f),
3141 Self::I2(this) => this.find_map(f),
3142 Self::I3(this) => this.find_map(f),
3143 Self::I4(this) => this.find_map(f),
3144 Self::I5(this) => this.find_map(f),
3145 Self::I6(this) => this.find_map(f),
3146 }
3147 }
3148 fn position<P>(&mut self, predicate: P) -> Option<usize>
3149 where
3150 Self: Sized,
3151 P: FnMut(Self::Item) -> bool,
3152 {
3153 match self {
3154 Self::I0(this) => this.position(predicate),
3155 Self::I1(this) => this.position(predicate),
3156 Self::I2(this) => this.position(predicate),
3157 Self::I3(this) => this.position(predicate),
3158 Self::I4(this) => this.position(predicate),
3159 Self::I5(this) => this.position(predicate),
3160 Self::I6(this) => this.position(predicate),
3161 }
3162 }
3163 fn max(self) -> Option<Self::Item>
3164 where
3165 Self: Sized,
3166 Self::Item: Ord,
3167 {
3168 match self {
3169 Self::I0(this) => this.max(),
3170 Self::I1(this) => this.max(),
3171 Self::I2(this) => this.max(),
3172 Self::I3(this) => this.max(),
3173 Self::I4(this) => this.max(),
3174 Self::I5(this) => this.max(),
3175 Self::I6(this) => this.max(),
3176 }
3177 }
3178 fn min(self) -> Option<Self::Item>
3179 where
3180 Self: Sized,
3181 Self::Item: Ord,
3182 {
3183 match self {
3184 Self::I0(this) => this.min(),
3185 Self::I1(this) => this.min(),
3186 Self::I2(this) => this.min(),
3187 Self::I3(this) => this.min(),
3188 Self::I4(this) => this.min(),
3189 Self::I5(this) => this.min(),
3190 Self::I6(this) => this.min(),
3191 }
3192 }
3193 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
3194 where
3195 Self: Sized,
3196 F: FnMut(&Self::Item) -> B,
3197 {
3198 match self {
3199 Self::I0(this) => this.max_by_key(f),
3200 Self::I1(this) => this.max_by_key(f),
3201 Self::I2(this) => this.max_by_key(f),
3202 Self::I3(this) => this.max_by_key(f),
3203 Self::I4(this) => this.max_by_key(f),
3204 Self::I5(this) => this.max_by_key(f),
3205 Self::I6(this) => this.max_by_key(f),
3206 }
3207 }
3208 fn max_by<F>(self, compare: F) -> Option<Self::Item>
3209 where
3210 Self: Sized,
3211 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
3212 {
3213 match self {
3214 Self::I0(this) => this.max_by(compare),
3215 Self::I1(this) => this.max_by(compare),
3216 Self::I2(this) => this.max_by(compare),
3217 Self::I3(this) => this.max_by(compare),
3218 Self::I4(this) => this.max_by(compare),
3219 Self::I5(this) => this.max_by(compare),
3220 Self::I6(this) => this.max_by(compare),
3221 }
3222 }
3223 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
3224 where
3225 Self: Sized,
3226 F: FnMut(&Self::Item) -> B,
3227 {
3228 match self {
3229 Self::I0(this) => this.min_by_key(f),
3230 Self::I1(this) => this.min_by_key(f),
3231 Self::I2(this) => this.min_by_key(f),
3232 Self::I3(this) => this.min_by_key(f),
3233 Self::I4(this) => this.min_by_key(f),
3234 Self::I5(this) => this.min_by_key(f),
3235 Self::I6(this) => this.min_by_key(f),
3236 }
3237 }
3238 fn min_by<F>(self, compare: F) -> Option<Self::Item>
3239 where
3240 Self: Sized,
3241 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
3242 {
3243 match self {
3244 Self::I0(this) => this.min_by(compare),
3245 Self::I1(this) => this.min_by(compare),
3246 Self::I2(this) => this.min_by(compare),
3247 Self::I3(this) => this.min_by(compare),
3248 Self::I4(this) => this.min_by(compare),
3249 Self::I5(this) => this.min_by(compare),
3250 Self::I6(this) => this.min_by(compare),
3251 }
3252 }
3253 fn sum<S>(self) -> S
3254 where
3255 Self: Sized,
3256 S: Sum<Self::Item>,
3257 {
3258 match self {
3259 Self::I0(this) => this.sum(),
3260 Self::I1(this) => this.sum(),
3261 Self::I2(this) => this.sum(),
3262 Self::I3(this) => this.sum(),
3263 Self::I4(this) => this.sum(),
3264 Self::I5(this) => this.sum(),
3265 Self::I6(this) => this.sum(),
3266 }
3267 }
3268 fn product<P>(self) -> P
3269 where
3270 Self: Sized,
3271 P: Product<Self::Item>,
3272 {
3273 match self {
3274 Self::I0(this) => this.product(),
3275 Self::I1(this) => this.product(),
3276 Self::I2(this) => this.product(),
3277 Self::I3(this) => this.product(),
3278 Self::I4(this) => this.product(),
3279 Self::I5(this) => this.product(),
3280 Self::I6(this) => this.product(),
3281 }
3282 }
3283 fn cmp<I>(self, other: I) -> Ordering
3284 where
3285 I: IntoIterator<Item = Self::Item>,
3286 Self::Item: Ord,
3287 Self: Sized,
3288 {
3289 match self {
3290 Self::I0(this) => this.cmp(other),
3291 Self::I1(this) => this.cmp(other),
3292 Self::I2(this) => this.cmp(other),
3293 Self::I3(this) => this.cmp(other),
3294 Self::I4(this) => this.cmp(other),
3295 Self::I5(this) => this.cmp(other),
3296 Self::I6(this) => this.cmp(other),
3297 }
3298 }
3299 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
3300 where
3301 I: IntoIterator,
3302 Self::Item: PartialOrd<I::Item>,
3303 Self: Sized,
3304 {
3305 match self {
3306 Self::I0(this) => this.partial_cmp(other),
3307 Self::I1(this) => this.partial_cmp(other),
3308 Self::I2(this) => this.partial_cmp(other),
3309 Self::I3(this) => this.partial_cmp(other),
3310 Self::I4(this) => this.partial_cmp(other),
3311 Self::I5(this) => this.partial_cmp(other),
3312 Self::I6(this) => this.partial_cmp(other),
3313 }
3314 }
3315 fn eq<I>(self, other: I) -> bool
3316 where
3317 I: IntoIterator,
3318 Self::Item: PartialEq<I::Item>,
3319 Self: Sized,
3320 {
3321 match self {
3322 Self::I0(this) => this.eq(other),
3323 Self::I1(this) => this.eq(other),
3324 Self::I2(this) => this.eq(other),
3325 Self::I3(this) => this.eq(other),
3326 Self::I4(this) => this.eq(other),
3327 Self::I5(this) => this.eq(other),
3328 Self::I6(this) => this.eq(other),
3329 }
3330 }
3331 fn ne<I>(self, other: I) -> bool
3332 where
3333 I: IntoIterator,
3334 Self::Item: PartialEq<I::Item>,
3335 Self: Sized,
3336 {
3337 match self {
3338 Self::I0(this) => this.ne(other),
3339 Self::I1(this) => this.ne(other),
3340 Self::I2(this) => this.ne(other),
3341 Self::I3(this) => this.ne(other),
3342 Self::I4(this) => this.ne(other),
3343 Self::I5(this) => this.ne(other),
3344 Self::I6(this) => this.ne(other),
3345 }
3346 }
3347 fn lt<I>(self, other: I) -> bool
3348 where
3349 I: IntoIterator,
3350 Self::Item: PartialOrd<I::Item>,
3351 Self: Sized,
3352 {
3353 match self {
3354 Self::I0(this) => this.lt(other),
3355 Self::I1(this) => this.lt(other),
3356 Self::I2(this) => this.lt(other),
3357 Self::I3(this) => this.lt(other),
3358 Self::I4(this) => this.lt(other),
3359 Self::I5(this) => this.lt(other),
3360 Self::I6(this) => this.lt(other),
3361 }
3362 }
3363 fn le<I>(self, other: I) -> bool
3364 where
3365 I: IntoIterator,
3366 Self::Item: PartialOrd<I::Item>,
3367 Self: Sized,
3368 {
3369 match self {
3370 Self::I0(this) => this.le(other),
3371 Self::I1(this) => this.le(other),
3372 Self::I2(this) => this.le(other),
3373 Self::I3(this) => this.le(other),
3374 Self::I4(this) => this.le(other),
3375 Self::I5(this) => this.le(other),
3376 Self::I6(this) => this.le(other),
3377 }
3378 }
3379 fn gt<I>(self, other: I) -> bool
3380 where
3381 I: IntoIterator,
3382 Self::Item: PartialOrd<I::Item>,
3383 Self: Sized,
3384 {
3385 match self {
3386 Self::I0(this) => this.gt(other),
3387 Self::I1(this) => this.gt(other),
3388 Self::I2(this) => this.gt(other),
3389 Self::I3(this) => this.gt(other),
3390 Self::I4(this) => this.gt(other),
3391 Self::I5(this) => this.gt(other),
3392 Self::I6(this) => this.gt(other),
3393 }
3394 }
3395 fn ge<I>(self, other: I) -> bool
3396 where
3397 I: IntoIterator,
3398 Self::Item: PartialOrd<I::Item>,
3399 Self: Sized,
3400 {
3401 match self {
3402 Self::I0(this) => this.ge(other),
3403 Self::I1(this) => this.ge(other),
3404 Self::I2(this) => this.ge(other),
3405 Self::I3(this) => this.ge(other),
3406 Self::I4(this) => this.ge(other),
3407 Self::I5(this) => this.ge(other),
3408 Self::I6(this) => this.ge(other),
3409 }
3410 }
3411 }
3412 impl<Item, I0, I1, I2, I3, I4, I5, I6> DoubleEndedIterator for Iter7<I0, I1, I2, I3, I4, I5, I6>
3413 where
3414 I0: DoubleEndedIterator<Item = Item>,
3415 I1: DoubleEndedIterator<Item = Item>,
3416 I2: DoubleEndedIterator<Item = Item>,
3417 I3: DoubleEndedIterator<Item = Item>,
3418 I4: DoubleEndedIterator<Item = Item>,
3419 I5: DoubleEndedIterator<Item = Item>,
3420 I6: DoubleEndedIterator<Item = Item>,
3421 {
3422 fn next_back(&mut self) -> Option<Self::Item> {
3423 match self {
3424 Self::I0(this) => this.next_back(),
3425 Self::I1(this) => this.next_back(),
3426 Self::I2(this) => this.next_back(),
3427 Self::I3(this) => this.next_back(),
3428 Self::I4(this) => this.next_back(),
3429 Self::I5(this) => this.next_back(),
3430 Self::I6(this) => this.next_back(),
3431 }
3432 }
3433 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
3434 match self {
3435 Self::I0(this) => this.nth_back(n),
3436 Self::I1(this) => this.nth_back(n),
3437 Self::I2(this) => this.nth_back(n),
3438 Self::I3(this) => this.nth_back(n),
3439 Self::I4(this) => this.nth_back(n),
3440 Self::I5(this) => this.nth_back(n),
3441 Self::I6(this) => this.nth_back(n),
3442 }
3443 }
3444 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
3445 where
3446 P: FnMut(&Self::Item) -> bool,
3447 {
3448 match self {
3449 Self::I0(this) => this.rfind(predicate),
3450 Self::I1(this) => this.rfind(predicate),
3451 Self::I2(this) => this.rfind(predicate),
3452 Self::I3(this) => this.rfind(predicate),
3453 Self::I4(this) => this.rfind(predicate),
3454 Self::I5(this) => this.rfind(predicate),
3455 Self::I6(this) => this.rfind(predicate),
3456 }
3457 }
3458 fn rfold<B, F>(self, init: B, f: F) -> B
3459 where
3460 Self: Sized,
3461 F: FnMut(B, Self::Item) -> B,
3462 {
3463 match self {
3464 Self::I0(this) => this.rfold(init, f),
3465 Self::I1(this) => this.rfold(init, f),
3466 Self::I2(this) => this.rfold(init, f),
3467 Self::I3(this) => this.rfold(init, f),
3468 Self::I4(this) => this.rfold(init, f),
3469 Self::I5(this) => this.rfold(init, f),
3470 Self::I6(this) => this.rfold(init, f),
3471 }
3472 }
3473 }
3474 impl<Item, I0, I1, I2, I3, I4, I5, I6> ExactSizeIterator for Iter7<I0, I1, I2, I3, I4, I5, I6>
3475 where
3476 I0: ExactSizeIterator<Item = Item>,
3477 I1: ExactSizeIterator<Item = Item>,
3478 I2: ExactSizeIterator<Item = Item>,
3479 I3: ExactSizeIterator<Item = Item>,
3480 I4: ExactSizeIterator<Item = Item>,
3481 I5: ExactSizeIterator<Item = Item>,
3482 I6: ExactSizeIterator<Item = Item>,
3483 {
3484 fn len(&self) -> usize {
3485 match self {
3486 Self::I0(this) => this.len(),
3487 Self::I1(this) => this.len(),
3488 Self::I2(this) => this.len(),
3489 Self::I3(this) => this.len(),
3490 Self::I4(this) => this.len(),
3491 Self::I5(this) => this.len(),
3492 Self::I6(this) => this.len(),
3493 }
3494 }
3495 }
3496 impl<Item, I0, I1, I2, I3, I4, I5, I6> FusedIterator for Iter7<I0, I1, I2, I3, I4, I5, I6>
3497 where
3498 I0: FusedIterator<Item = Item>,
3499 I1: FusedIterator<Item = Item>,
3500 I2: FusedIterator<Item = Item>,
3501 I3: FusedIterator<Item = Item>,
3502 I4: FusedIterator<Item = Item>,
3503 I5: FusedIterator<Item = Item>,
3504 I6: FusedIterator<Item = Item>,
3505 {
3506 }
3507}
3508pub mod iter8 {
3509 use super::*;
3510 use core::iter::FusedIterator;
3511 #[derive(Debug, Clone, Copy)]
3512 pub enum Iter8<I0, I1, I2, I3, I4, I5, I6, I7> {
3513 I0(I0),
3514 I1(I1),
3515 I2(I2),
3516 I3(I3),
3517 I4(I4),
3518 I5(I5),
3519 I6(I6),
3520 I7(I7),
3521 }
3522 pub trait IntoIter0: IntoIterator {
3523 #[allow(clippy::type_complexity)]
3524 fn into_iter0<I1, I2, I3, I4, I5, I6, I7>(
3525 self,
3526 ) -> Iter8<Self::IntoIter, I1, I2, I3, I4, I5, I6, I7>;
3527 }
3528 impl<T: IntoIterator> IntoIter0 for T {
3529 #[allow(clippy::type_complexity)]
3530 fn into_iter0<I1, I2, I3, I4, I5, I6, I7>(
3531 self,
3532 ) -> Iter8<Self::IntoIter, I1, I2, I3, I4, I5, I6, I7> {
3533 Iter8::I0(self.into_iter())
3534 }
3535 }
3536 pub trait IntoIter1: IntoIterator {
3537 #[allow(clippy::type_complexity)]
3538 fn into_iter1<I0, I2, I3, I4, I5, I6, I7>(
3539 self,
3540 ) -> Iter8<I0, Self::IntoIter, I2, I3, I4, I5, I6, I7>;
3541 }
3542 impl<T: IntoIterator> IntoIter1 for T {
3543 #[allow(clippy::type_complexity)]
3544 fn into_iter1<I0, I2, I3, I4, I5, I6, I7>(
3545 self,
3546 ) -> Iter8<I0, Self::IntoIter, I2, I3, I4, I5, I6, I7> {
3547 Iter8::I1(self.into_iter())
3548 }
3549 }
3550 pub trait IntoIter2: IntoIterator {
3551 #[allow(clippy::type_complexity)]
3552 fn into_iter2<I0, I1, I3, I4, I5, I6, I7>(
3553 self,
3554 ) -> Iter8<I0, I1, Self::IntoIter, I3, I4, I5, I6, I7>;
3555 }
3556 impl<T: IntoIterator> IntoIter2 for T {
3557 #[allow(clippy::type_complexity)]
3558 fn into_iter2<I0, I1, I3, I4, I5, I6, I7>(
3559 self,
3560 ) -> Iter8<I0, I1, Self::IntoIter, I3, I4, I5, I6, I7> {
3561 Iter8::I2(self.into_iter())
3562 }
3563 }
3564 pub trait IntoIter3: IntoIterator {
3565 #[allow(clippy::type_complexity)]
3566 fn into_iter3<I0, I1, I2, I4, I5, I6, I7>(
3567 self,
3568 ) -> Iter8<I0, I1, I2, Self::IntoIter, I4, I5, I6, I7>;
3569 }
3570 impl<T: IntoIterator> IntoIter3 for T {
3571 #[allow(clippy::type_complexity)]
3572 fn into_iter3<I0, I1, I2, I4, I5, I6, I7>(
3573 self,
3574 ) -> Iter8<I0, I1, I2, Self::IntoIter, I4, I5, I6, I7> {
3575 Iter8::I3(self.into_iter())
3576 }
3577 }
3578 pub trait IntoIter4: IntoIterator {
3579 #[allow(clippy::type_complexity)]
3580 fn into_iter4<I0, I1, I2, I3, I5, I6, I7>(
3581 self,
3582 ) -> Iter8<I0, I1, I2, I3, Self::IntoIter, I5, I6, I7>;
3583 }
3584 impl<T: IntoIterator> IntoIter4 for T {
3585 #[allow(clippy::type_complexity)]
3586 fn into_iter4<I0, I1, I2, I3, I5, I6, I7>(
3587 self,
3588 ) -> Iter8<I0, I1, I2, I3, Self::IntoIter, I5, I6, I7> {
3589 Iter8::I4(self.into_iter())
3590 }
3591 }
3592 pub trait IntoIter5: IntoIterator {
3593 #[allow(clippy::type_complexity)]
3594 fn into_iter5<I0, I1, I2, I3, I4, I6, I7>(
3595 self,
3596 ) -> Iter8<I0, I1, I2, I3, I4, Self::IntoIter, I6, I7>;
3597 }
3598 impl<T: IntoIterator> IntoIter5 for T {
3599 #[allow(clippy::type_complexity)]
3600 fn into_iter5<I0, I1, I2, I3, I4, I6, I7>(
3601 self,
3602 ) -> Iter8<I0, I1, I2, I3, I4, Self::IntoIter, I6, I7> {
3603 Iter8::I5(self.into_iter())
3604 }
3605 }
3606 pub trait IntoIter6: IntoIterator {
3607 #[allow(clippy::type_complexity)]
3608 fn into_iter6<I0, I1, I2, I3, I4, I5, I7>(
3609 self,
3610 ) -> Iter8<I0, I1, I2, I3, I4, I5, Self::IntoIter, I7>;
3611 }
3612 impl<T: IntoIterator> IntoIter6 for T {
3613 #[allow(clippy::type_complexity)]
3614 fn into_iter6<I0, I1, I2, I3, I4, I5, I7>(
3615 self,
3616 ) -> Iter8<I0, I1, I2, I3, I4, I5, Self::IntoIter, I7> {
3617 Iter8::I6(self.into_iter())
3618 }
3619 }
3620 pub trait IntoIter7: IntoIterator {
3621 #[allow(clippy::type_complexity)]
3622 fn into_iter7<I0, I1, I2, I3, I4, I5, I6>(
3623 self,
3624 ) -> Iter8<I0, I1, I2, I3, I4, I5, I6, Self::IntoIter>;
3625 }
3626 impl<T: IntoIterator> IntoIter7 for T {
3627 #[allow(clippy::type_complexity)]
3628 fn into_iter7<I0, I1, I2, I3, I4, I5, I6>(
3629 self,
3630 ) -> Iter8<I0, I1, I2, I3, I4, I5, I6, Self::IntoIter> {
3631 Iter8::I7(self.into_iter())
3632 }
3633 }
3634 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7> Iterator for Iter8<I0, I1, I2, I3, I4, I5, I6, I7>
3635 where
3636 I0: Iterator<Item = Item>,
3637 I1: Iterator<Item = Item>,
3638 I2: Iterator<Item = Item>,
3639 I3: Iterator<Item = Item>,
3640 I4: Iterator<Item = Item>,
3641 I5: Iterator<Item = Item>,
3642 I6: Iterator<Item = Item>,
3643 I7: Iterator<Item = Item>,
3644 {
3645 type Item = Item;
3646 fn next(&mut self) -> Option<Self::Item> {
3647 match self {
3648 Self::I0(this) => this.next(),
3649 Self::I1(this) => this.next(),
3650 Self::I2(this) => this.next(),
3651 Self::I3(this) => this.next(),
3652 Self::I4(this) => this.next(),
3653 Self::I5(this) => this.next(),
3654 Self::I6(this) => this.next(),
3655 Self::I7(this) => this.next(),
3656 }
3657 }
3658 fn size_hint(&self) -> (usize, Option<usize>) {
3659 match self {
3660 Self::I0(this) => this.size_hint(),
3661 Self::I1(this) => this.size_hint(),
3662 Self::I2(this) => this.size_hint(),
3663 Self::I3(this) => this.size_hint(),
3664 Self::I4(this) => this.size_hint(),
3665 Self::I5(this) => this.size_hint(),
3666 Self::I6(this) => this.size_hint(),
3667 Self::I7(this) => this.size_hint(),
3668 }
3669 }
3670 fn count(self) -> usize
3671 where
3672 Self: Sized,
3673 {
3674 match self {
3675 Self::I0(this) => this.count(),
3676 Self::I1(this) => this.count(),
3677 Self::I2(this) => this.count(),
3678 Self::I3(this) => this.count(),
3679 Self::I4(this) => this.count(),
3680 Self::I5(this) => this.count(),
3681 Self::I6(this) => this.count(),
3682 Self::I7(this) => this.count(),
3683 }
3684 }
3685 fn last(self) -> Option<Self::Item>
3686 where
3687 Self: Sized,
3688 {
3689 match self {
3690 Self::I0(this) => this.last(),
3691 Self::I1(this) => this.last(),
3692 Self::I2(this) => this.last(),
3693 Self::I3(this) => this.last(),
3694 Self::I4(this) => this.last(),
3695 Self::I5(this) => this.last(),
3696 Self::I6(this) => this.last(),
3697 Self::I7(this) => this.last(),
3698 }
3699 }
3700 fn nth(&mut self, n: usize) -> Option<Self::Item> {
3701 match self {
3702 Self::I0(this) => this.nth(n),
3703 Self::I1(this) => this.nth(n),
3704 Self::I2(this) => this.nth(n),
3705 Self::I3(this) => this.nth(n),
3706 Self::I4(this) => this.nth(n),
3707 Self::I5(this) => this.nth(n),
3708 Self::I6(this) => this.nth(n),
3709 Self::I7(this) => this.nth(n),
3710 }
3711 }
3712 fn for_each<F>(self, f: F)
3713 where
3714 Self: Sized,
3715 F: FnMut(Self::Item),
3716 {
3717 match self {
3718 Self::I0(this) => this.for_each(f),
3719 Self::I1(this) => this.for_each(f),
3720 Self::I2(this) => this.for_each(f),
3721 Self::I3(this) => this.for_each(f),
3722 Self::I4(this) => this.for_each(f),
3723 Self::I5(this) => this.for_each(f),
3724 Self::I6(this) => this.for_each(f),
3725 Self::I7(this) => this.for_each(f),
3726 }
3727 }
3728 fn collect<B: FromIterator<Self::Item>>(self) -> B
3729 where
3730 Self: Sized,
3731 {
3732 match self {
3733 Self::I0(this) => this.collect(),
3734 Self::I1(this) => this.collect(),
3735 Self::I2(this) => this.collect(),
3736 Self::I3(this) => this.collect(),
3737 Self::I4(this) => this.collect(),
3738 Self::I5(this) => this.collect(),
3739 Self::I6(this) => this.collect(),
3740 Self::I7(this) => this.collect(),
3741 }
3742 }
3743 fn partition<B, F>(self, f: F) -> (B, B)
3744 where
3745 Self: Sized,
3746 B: Default + Extend<Self::Item>,
3747 F: FnMut(&Self::Item) -> bool,
3748 {
3749 match self {
3750 Self::I0(this) => this.partition(f),
3751 Self::I1(this) => this.partition(f),
3752 Self::I2(this) => this.partition(f),
3753 Self::I3(this) => this.partition(f),
3754 Self::I4(this) => this.partition(f),
3755 Self::I5(this) => this.partition(f),
3756 Self::I6(this) => this.partition(f),
3757 Self::I7(this) => this.partition(f),
3758 }
3759 }
3760 fn fold<B, F>(self, init: B, f: F) -> B
3761 where
3762 Self: Sized,
3763 F: FnMut(B, Self::Item) -> B,
3764 {
3765 match self {
3766 Self::I0(this) => this.fold(init, f),
3767 Self::I1(this) => this.fold(init, f),
3768 Self::I2(this) => this.fold(init, f),
3769 Self::I3(this) => this.fold(init, f),
3770 Self::I4(this) => this.fold(init, f),
3771 Self::I5(this) => this.fold(init, f),
3772 Self::I6(this) => this.fold(init, f),
3773 Self::I7(this) => this.fold(init, f),
3774 }
3775 }
3776 fn reduce<F>(self, f: F) -> Option<Self::Item>
3777 where
3778 Self: Sized,
3779 F: FnMut(Self::Item, Self::Item) -> Self::Item,
3780 {
3781 match self {
3782 Self::I0(this) => this.reduce(f),
3783 Self::I1(this) => this.reduce(f),
3784 Self::I2(this) => this.reduce(f),
3785 Self::I3(this) => this.reduce(f),
3786 Self::I4(this) => this.reduce(f),
3787 Self::I5(this) => this.reduce(f),
3788 Self::I6(this) => this.reduce(f),
3789 Self::I7(this) => this.reduce(f),
3790 }
3791 }
3792 fn all<F>(&mut self, f: F) -> bool
3793 where
3794 Self: Sized,
3795 F: FnMut(Self::Item) -> bool,
3796 {
3797 match self {
3798 Self::I0(this) => this.all(f),
3799 Self::I1(this) => this.all(f),
3800 Self::I2(this) => this.all(f),
3801 Self::I3(this) => this.all(f),
3802 Self::I4(this) => this.all(f),
3803 Self::I5(this) => this.all(f),
3804 Self::I6(this) => this.all(f),
3805 Self::I7(this) => this.all(f),
3806 }
3807 }
3808 fn any<F>(&mut self, f: F) -> bool
3809 where
3810 Self: Sized,
3811 F: FnMut(Self::Item) -> bool,
3812 {
3813 match self {
3814 Self::I0(this) => this.any(f),
3815 Self::I1(this) => this.any(f),
3816 Self::I2(this) => this.any(f),
3817 Self::I3(this) => this.any(f),
3818 Self::I4(this) => this.any(f),
3819 Self::I5(this) => this.any(f),
3820 Self::I6(this) => this.any(f),
3821 Self::I7(this) => this.any(f),
3822 }
3823 }
3824 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
3825 where
3826 Self: Sized,
3827 P: FnMut(&Self::Item) -> bool,
3828 {
3829 match self {
3830 Self::I0(this) => this.find(predicate),
3831 Self::I1(this) => this.find(predicate),
3832 Self::I2(this) => this.find(predicate),
3833 Self::I3(this) => this.find(predicate),
3834 Self::I4(this) => this.find(predicate),
3835 Self::I5(this) => this.find(predicate),
3836 Self::I6(this) => this.find(predicate),
3837 Self::I7(this) => this.find(predicate),
3838 }
3839 }
3840 fn find_map<B, F>(&mut self, f: F) -> Option<B>
3841 where
3842 Self: Sized,
3843 F: FnMut(Self::Item) -> Option<B>,
3844 {
3845 match self {
3846 Self::I0(this) => this.find_map(f),
3847 Self::I1(this) => this.find_map(f),
3848 Self::I2(this) => this.find_map(f),
3849 Self::I3(this) => this.find_map(f),
3850 Self::I4(this) => this.find_map(f),
3851 Self::I5(this) => this.find_map(f),
3852 Self::I6(this) => this.find_map(f),
3853 Self::I7(this) => this.find_map(f),
3854 }
3855 }
3856 fn position<P>(&mut self, predicate: P) -> Option<usize>
3857 where
3858 Self: Sized,
3859 P: FnMut(Self::Item) -> bool,
3860 {
3861 match self {
3862 Self::I0(this) => this.position(predicate),
3863 Self::I1(this) => this.position(predicate),
3864 Self::I2(this) => this.position(predicate),
3865 Self::I3(this) => this.position(predicate),
3866 Self::I4(this) => this.position(predicate),
3867 Self::I5(this) => this.position(predicate),
3868 Self::I6(this) => this.position(predicate),
3869 Self::I7(this) => this.position(predicate),
3870 }
3871 }
3872 fn max(self) -> Option<Self::Item>
3873 where
3874 Self: Sized,
3875 Self::Item: Ord,
3876 {
3877 match self {
3878 Self::I0(this) => this.max(),
3879 Self::I1(this) => this.max(),
3880 Self::I2(this) => this.max(),
3881 Self::I3(this) => this.max(),
3882 Self::I4(this) => this.max(),
3883 Self::I5(this) => this.max(),
3884 Self::I6(this) => this.max(),
3885 Self::I7(this) => this.max(),
3886 }
3887 }
3888 fn min(self) -> Option<Self::Item>
3889 where
3890 Self: Sized,
3891 Self::Item: Ord,
3892 {
3893 match self {
3894 Self::I0(this) => this.min(),
3895 Self::I1(this) => this.min(),
3896 Self::I2(this) => this.min(),
3897 Self::I3(this) => this.min(),
3898 Self::I4(this) => this.min(),
3899 Self::I5(this) => this.min(),
3900 Self::I6(this) => this.min(),
3901 Self::I7(this) => this.min(),
3902 }
3903 }
3904 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
3905 where
3906 Self: Sized,
3907 F: FnMut(&Self::Item) -> B,
3908 {
3909 match self {
3910 Self::I0(this) => this.max_by_key(f),
3911 Self::I1(this) => this.max_by_key(f),
3912 Self::I2(this) => this.max_by_key(f),
3913 Self::I3(this) => this.max_by_key(f),
3914 Self::I4(this) => this.max_by_key(f),
3915 Self::I5(this) => this.max_by_key(f),
3916 Self::I6(this) => this.max_by_key(f),
3917 Self::I7(this) => this.max_by_key(f),
3918 }
3919 }
3920 fn max_by<F>(self, compare: F) -> Option<Self::Item>
3921 where
3922 Self: Sized,
3923 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
3924 {
3925 match self {
3926 Self::I0(this) => this.max_by(compare),
3927 Self::I1(this) => this.max_by(compare),
3928 Self::I2(this) => this.max_by(compare),
3929 Self::I3(this) => this.max_by(compare),
3930 Self::I4(this) => this.max_by(compare),
3931 Self::I5(this) => this.max_by(compare),
3932 Self::I6(this) => this.max_by(compare),
3933 Self::I7(this) => this.max_by(compare),
3934 }
3935 }
3936 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
3937 where
3938 Self: Sized,
3939 F: FnMut(&Self::Item) -> B,
3940 {
3941 match self {
3942 Self::I0(this) => this.min_by_key(f),
3943 Self::I1(this) => this.min_by_key(f),
3944 Self::I2(this) => this.min_by_key(f),
3945 Self::I3(this) => this.min_by_key(f),
3946 Self::I4(this) => this.min_by_key(f),
3947 Self::I5(this) => this.min_by_key(f),
3948 Self::I6(this) => this.min_by_key(f),
3949 Self::I7(this) => this.min_by_key(f),
3950 }
3951 }
3952 fn min_by<F>(self, compare: F) -> Option<Self::Item>
3953 where
3954 Self: Sized,
3955 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
3956 {
3957 match self {
3958 Self::I0(this) => this.min_by(compare),
3959 Self::I1(this) => this.min_by(compare),
3960 Self::I2(this) => this.min_by(compare),
3961 Self::I3(this) => this.min_by(compare),
3962 Self::I4(this) => this.min_by(compare),
3963 Self::I5(this) => this.min_by(compare),
3964 Self::I6(this) => this.min_by(compare),
3965 Self::I7(this) => this.min_by(compare),
3966 }
3967 }
3968 fn sum<S>(self) -> S
3969 where
3970 Self: Sized,
3971 S: Sum<Self::Item>,
3972 {
3973 match self {
3974 Self::I0(this) => this.sum(),
3975 Self::I1(this) => this.sum(),
3976 Self::I2(this) => this.sum(),
3977 Self::I3(this) => this.sum(),
3978 Self::I4(this) => this.sum(),
3979 Self::I5(this) => this.sum(),
3980 Self::I6(this) => this.sum(),
3981 Self::I7(this) => this.sum(),
3982 }
3983 }
3984 fn product<P>(self) -> P
3985 where
3986 Self: Sized,
3987 P: Product<Self::Item>,
3988 {
3989 match self {
3990 Self::I0(this) => this.product(),
3991 Self::I1(this) => this.product(),
3992 Self::I2(this) => this.product(),
3993 Self::I3(this) => this.product(),
3994 Self::I4(this) => this.product(),
3995 Self::I5(this) => this.product(),
3996 Self::I6(this) => this.product(),
3997 Self::I7(this) => this.product(),
3998 }
3999 }
4000 fn cmp<I>(self, other: I) -> Ordering
4001 where
4002 I: IntoIterator<Item = Self::Item>,
4003 Self::Item: Ord,
4004 Self: Sized,
4005 {
4006 match self {
4007 Self::I0(this) => this.cmp(other),
4008 Self::I1(this) => this.cmp(other),
4009 Self::I2(this) => this.cmp(other),
4010 Self::I3(this) => this.cmp(other),
4011 Self::I4(this) => this.cmp(other),
4012 Self::I5(this) => this.cmp(other),
4013 Self::I6(this) => this.cmp(other),
4014 Self::I7(this) => this.cmp(other),
4015 }
4016 }
4017 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
4018 where
4019 I: IntoIterator,
4020 Self::Item: PartialOrd<I::Item>,
4021 Self: Sized,
4022 {
4023 match self {
4024 Self::I0(this) => this.partial_cmp(other),
4025 Self::I1(this) => this.partial_cmp(other),
4026 Self::I2(this) => this.partial_cmp(other),
4027 Self::I3(this) => this.partial_cmp(other),
4028 Self::I4(this) => this.partial_cmp(other),
4029 Self::I5(this) => this.partial_cmp(other),
4030 Self::I6(this) => this.partial_cmp(other),
4031 Self::I7(this) => this.partial_cmp(other),
4032 }
4033 }
4034 fn eq<I>(self, other: I) -> bool
4035 where
4036 I: IntoIterator,
4037 Self::Item: PartialEq<I::Item>,
4038 Self: Sized,
4039 {
4040 match self {
4041 Self::I0(this) => this.eq(other),
4042 Self::I1(this) => this.eq(other),
4043 Self::I2(this) => this.eq(other),
4044 Self::I3(this) => this.eq(other),
4045 Self::I4(this) => this.eq(other),
4046 Self::I5(this) => this.eq(other),
4047 Self::I6(this) => this.eq(other),
4048 Self::I7(this) => this.eq(other),
4049 }
4050 }
4051 fn ne<I>(self, other: I) -> bool
4052 where
4053 I: IntoIterator,
4054 Self::Item: PartialEq<I::Item>,
4055 Self: Sized,
4056 {
4057 match self {
4058 Self::I0(this) => this.ne(other),
4059 Self::I1(this) => this.ne(other),
4060 Self::I2(this) => this.ne(other),
4061 Self::I3(this) => this.ne(other),
4062 Self::I4(this) => this.ne(other),
4063 Self::I5(this) => this.ne(other),
4064 Self::I6(this) => this.ne(other),
4065 Self::I7(this) => this.ne(other),
4066 }
4067 }
4068 fn lt<I>(self, other: I) -> bool
4069 where
4070 I: IntoIterator,
4071 Self::Item: PartialOrd<I::Item>,
4072 Self: Sized,
4073 {
4074 match self {
4075 Self::I0(this) => this.lt(other),
4076 Self::I1(this) => this.lt(other),
4077 Self::I2(this) => this.lt(other),
4078 Self::I3(this) => this.lt(other),
4079 Self::I4(this) => this.lt(other),
4080 Self::I5(this) => this.lt(other),
4081 Self::I6(this) => this.lt(other),
4082 Self::I7(this) => this.lt(other),
4083 }
4084 }
4085 fn le<I>(self, other: I) -> bool
4086 where
4087 I: IntoIterator,
4088 Self::Item: PartialOrd<I::Item>,
4089 Self: Sized,
4090 {
4091 match self {
4092 Self::I0(this) => this.le(other),
4093 Self::I1(this) => this.le(other),
4094 Self::I2(this) => this.le(other),
4095 Self::I3(this) => this.le(other),
4096 Self::I4(this) => this.le(other),
4097 Self::I5(this) => this.le(other),
4098 Self::I6(this) => this.le(other),
4099 Self::I7(this) => this.le(other),
4100 }
4101 }
4102 fn gt<I>(self, other: I) -> bool
4103 where
4104 I: IntoIterator,
4105 Self::Item: PartialOrd<I::Item>,
4106 Self: Sized,
4107 {
4108 match self {
4109 Self::I0(this) => this.gt(other),
4110 Self::I1(this) => this.gt(other),
4111 Self::I2(this) => this.gt(other),
4112 Self::I3(this) => this.gt(other),
4113 Self::I4(this) => this.gt(other),
4114 Self::I5(this) => this.gt(other),
4115 Self::I6(this) => this.gt(other),
4116 Self::I7(this) => this.gt(other),
4117 }
4118 }
4119 fn ge<I>(self, other: I) -> bool
4120 where
4121 I: IntoIterator,
4122 Self::Item: PartialOrd<I::Item>,
4123 Self: Sized,
4124 {
4125 match self {
4126 Self::I0(this) => this.ge(other),
4127 Self::I1(this) => this.ge(other),
4128 Self::I2(this) => this.ge(other),
4129 Self::I3(this) => this.ge(other),
4130 Self::I4(this) => this.ge(other),
4131 Self::I5(this) => this.ge(other),
4132 Self::I6(this) => this.ge(other),
4133 Self::I7(this) => this.ge(other),
4134 }
4135 }
4136 }
4137 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7> DoubleEndedIterator
4138 for Iter8<I0, I1, I2, I3, I4, I5, I6, I7>
4139 where
4140 I0: DoubleEndedIterator<Item = Item>,
4141 I1: DoubleEndedIterator<Item = Item>,
4142 I2: DoubleEndedIterator<Item = Item>,
4143 I3: DoubleEndedIterator<Item = Item>,
4144 I4: DoubleEndedIterator<Item = Item>,
4145 I5: DoubleEndedIterator<Item = Item>,
4146 I6: DoubleEndedIterator<Item = Item>,
4147 I7: DoubleEndedIterator<Item = Item>,
4148 {
4149 fn next_back(&mut self) -> Option<Self::Item> {
4150 match self {
4151 Self::I0(this) => this.next_back(),
4152 Self::I1(this) => this.next_back(),
4153 Self::I2(this) => this.next_back(),
4154 Self::I3(this) => this.next_back(),
4155 Self::I4(this) => this.next_back(),
4156 Self::I5(this) => this.next_back(),
4157 Self::I6(this) => this.next_back(),
4158 Self::I7(this) => this.next_back(),
4159 }
4160 }
4161 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
4162 match self {
4163 Self::I0(this) => this.nth_back(n),
4164 Self::I1(this) => this.nth_back(n),
4165 Self::I2(this) => this.nth_back(n),
4166 Self::I3(this) => this.nth_back(n),
4167 Self::I4(this) => this.nth_back(n),
4168 Self::I5(this) => this.nth_back(n),
4169 Self::I6(this) => this.nth_back(n),
4170 Self::I7(this) => this.nth_back(n),
4171 }
4172 }
4173 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
4174 where
4175 P: FnMut(&Self::Item) -> bool,
4176 {
4177 match self {
4178 Self::I0(this) => this.rfind(predicate),
4179 Self::I1(this) => this.rfind(predicate),
4180 Self::I2(this) => this.rfind(predicate),
4181 Self::I3(this) => this.rfind(predicate),
4182 Self::I4(this) => this.rfind(predicate),
4183 Self::I5(this) => this.rfind(predicate),
4184 Self::I6(this) => this.rfind(predicate),
4185 Self::I7(this) => this.rfind(predicate),
4186 }
4187 }
4188 fn rfold<B, F>(self, init: B, f: F) -> B
4189 where
4190 Self: Sized,
4191 F: FnMut(B, Self::Item) -> B,
4192 {
4193 match self {
4194 Self::I0(this) => this.rfold(init, f),
4195 Self::I1(this) => this.rfold(init, f),
4196 Self::I2(this) => this.rfold(init, f),
4197 Self::I3(this) => this.rfold(init, f),
4198 Self::I4(this) => this.rfold(init, f),
4199 Self::I5(this) => this.rfold(init, f),
4200 Self::I6(this) => this.rfold(init, f),
4201 Self::I7(this) => this.rfold(init, f),
4202 }
4203 }
4204 }
4205 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7> ExactSizeIterator
4206 for Iter8<I0, I1, I2, I3, I4, I5, I6, I7>
4207 where
4208 I0: ExactSizeIterator<Item = Item>,
4209 I1: ExactSizeIterator<Item = Item>,
4210 I2: ExactSizeIterator<Item = Item>,
4211 I3: ExactSizeIterator<Item = Item>,
4212 I4: ExactSizeIterator<Item = Item>,
4213 I5: ExactSizeIterator<Item = Item>,
4214 I6: ExactSizeIterator<Item = Item>,
4215 I7: ExactSizeIterator<Item = Item>,
4216 {
4217 fn len(&self) -> usize {
4218 match self {
4219 Self::I0(this) => this.len(),
4220 Self::I1(this) => this.len(),
4221 Self::I2(this) => this.len(),
4222 Self::I3(this) => this.len(),
4223 Self::I4(this) => this.len(),
4224 Self::I5(this) => this.len(),
4225 Self::I6(this) => this.len(),
4226 Self::I7(this) => this.len(),
4227 }
4228 }
4229 }
4230 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7> FusedIterator for Iter8<I0, I1, I2, I3, I4, I5, I6, I7>
4231 where
4232 I0: FusedIterator<Item = Item>,
4233 I1: FusedIterator<Item = Item>,
4234 I2: FusedIterator<Item = Item>,
4235 I3: FusedIterator<Item = Item>,
4236 I4: FusedIterator<Item = Item>,
4237 I5: FusedIterator<Item = Item>,
4238 I6: FusedIterator<Item = Item>,
4239 I7: FusedIterator<Item = Item>,
4240 {
4241 }
4242}
4243pub mod iter9 {
4244 use super::*;
4245 use core::iter::FusedIterator;
4246 #[derive(Debug, Clone, Copy)]
4247 pub enum Iter9<I0, I1, I2, I3, I4, I5, I6, I7, I8> {
4248 I0(I0),
4249 I1(I1),
4250 I2(I2),
4251 I3(I3),
4252 I4(I4),
4253 I5(I5),
4254 I6(I6),
4255 I7(I7),
4256 I8(I8),
4257 }
4258 pub trait IntoIter0: IntoIterator {
4259 #[allow(clippy::type_complexity)]
4260 fn into_iter0<I1, I2, I3, I4, I5, I6, I7, I8>(
4261 self,
4262 ) -> Iter9<Self::IntoIter, I1, I2, I3, I4, I5, I6, I7, I8>;
4263 }
4264 impl<T: IntoIterator> IntoIter0 for T {
4265 #[allow(clippy::type_complexity)]
4266 fn into_iter0<I1, I2, I3, I4, I5, I6, I7, I8>(
4267 self,
4268 ) -> Iter9<Self::IntoIter, I1, I2, I3, I4, I5, I6, I7, I8> {
4269 Iter9::I0(self.into_iter())
4270 }
4271 }
4272 pub trait IntoIter1: IntoIterator {
4273 #[allow(clippy::type_complexity)]
4274 fn into_iter1<I0, I2, I3, I4, I5, I6, I7, I8>(
4275 self,
4276 ) -> Iter9<I0, Self::IntoIter, I2, I3, I4, I5, I6, I7, I8>;
4277 }
4278 impl<T: IntoIterator> IntoIter1 for T {
4279 #[allow(clippy::type_complexity)]
4280 fn into_iter1<I0, I2, I3, I4, I5, I6, I7, I8>(
4281 self,
4282 ) -> Iter9<I0, Self::IntoIter, I2, I3, I4, I5, I6, I7, I8> {
4283 Iter9::I1(self.into_iter())
4284 }
4285 }
4286 pub trait IntoIter2: IntoIterator {
4287 #[allow(clippy::type_complexity)]
4288 fn into_iter2<I0, I1, I3, I4, I5, I6, I7, I8>(
4289 self,
4290 ) -> Iter9<I0, I1, Self::IntoIter, I3, I4, I5, I6, I7, I8>;
4291 }
4292 impl<T: IntoIterator> IntoIter2 for T {
4293 #[allow(clippy::type_complexity)]
4294 fn into_iter2<I0, I1, I3, I4, I5, I6, I7, I8>(
4295 self,
4296 ) -> Iter9<I0, I1, Self::IntoIter, I3, I4, I5, I6, I7, I8> {
4297 Iter9::I2(self.into_iter())
4298 }
4299 }
4300 pub trait IntoIter3: IntoIterator {
4301 #[allow(clippy::type_complexity)]
4302 fn into_iter3<I0, I1, I2, I4, I5, I6, I7, I8>(
4303 self,
4304 ) -> Iter9<I0, I1, I2, Self::IntoIter, I4, I5, I6, I7, I8>;
4305 }
4306 impl<T: IntoIterator> IntoIter3 for T {
4307 #[allow(clippy::type_complexity)]
4308 fn into_iter3<I0, I1, I2, I4, I5, I6, I7, I8>(
4309 self,
4310 ) -> Iter9<I0, I1, I2, Self::IntoIter, I4, I5, I6, I7, I8> {
4311 Iter9::I3(self.into_iter())
4312 }
4313 }
4314 pub trait IntoIter4: IntoIterator {
4315 #[allow(clippy::type_complexity)]
4316 fn into_iter4<I0, I1, I2, I3, I5, I6, I7, I8>(
4317 self,
4318 ) -> Iter9<I0, I1, I2, I3, Self::IntoIter, I5, I6, I7, I8>;
4319 }
4320 impl<T: IntoIterator> IntoIter4 for T {
4321 #[allow(clippy::type_complexity)]
4322 fn into_iter4<I0, I1, I2, I3, I5, I6, I7, I8>(
4323 self,
4324 ) -> Iter9<I0, I1, I2, I3, Self::IntoIter, I5, I6, I7, I8> {
4325 Iter9::I4(self.into_iter())
4326 }
4327 }
4328 pub trait IntoIter5: IntoIterator {
4329 #[allow(clippy::type_complexity)]
4330 fn into_iter5<I0, I1, I2, I3, I4, I6, I7, I8>(
4331 self,
4332 ) -> Iter9<I0, I1, I2, I3, I4, Self::IntoIter, I6, I7, I8>;
4333 }
4334 impl<T: IntoIterator> IntoIter5 for T {
4335 #[allow(clippy::type_complexity)]
4336 fn into_iter5<I0, I1, I2, I3, I4, I6, I7, I8>(
4337 self,
4338 ) -> Iter9<I0, I1, I2, I3, I4, Self::IntoIter, I6, I7, I8> {
4339 Iter9::I5(self.into_iter())
4340 }
4341 }
4342 pub trait IntoIter6: IntoIterator {
4343 #[allow(clippy::type_complexity)]
4344 fn into_iter6<I0, I1, I2, I3, I4, I5, I7, I8>(
4345 self,
4346 ) -> Iter9<I0, I1, I2, I3, I4, I5, Self::IntoIter, I7, I8>;
4347 }
4348 impl<T: IntoIterator> IntoIter6 for T {
4349 #[allow(clippy::type_complexity)]
4350 fn into_iter6<I0, I1, I2, I3, I4, I5, I7, I8>(
4351 self,
4352 ) -> Iter9<I0, I1, I2, I3, I4, I5, Self::IntoIter, I7, I8> {
4353 Iter9::I6(self.into_iter())
4354 }
4355 }
4356 pub trait IntoIter7: IntoIterator {
4357 #[allow(clippy::type_complexity)]
4358 fn into_iter7<I0, I1, I2, I3, I4, I5, I6, I8>(
4359 self,
4360 ) -> Iter9<I0, I1, I2, I3, I4, I5, I6, Self::IntoIter, I8>;
4361 }
4362 impl<T: IntoIterator> IntoIter7 for T {
4363 #[allow(clippy::type_complexity)]
4364 fn into_iter7<I0, I1, I2, I3, I4, I5, I6, I8>(
4365 self,
4366 ) -> Iter9<I0, I1, I2, I3, I4, I5, I6, Self::IntoIter, I8> {
4367 Iter9::I7(self.into_iter())
4368 }
4369 }
4370 pub trait IntoIter8: IntoIterator {
4371 #[allow(clippy::type_complexity)]
4372 fn into_iter8<I0, I1, I2, I3, I4, I5, I6, I7>(
4373 self,
4374 ) -> Iter9<I0, I1, I2, I3, I4, I5, I6, I7, Self::IntoIter>;
4375 }
4376 impl<T: IntoIterator> IntoIter8 for T {
4377 #[allow(clippy::type_complexity)]
4378 fn into_iter8<I0, I1, I2, I3, I4, I5, I6, I7>(
4379 self,
4380 ) -> Iter9<I0, I1, I2, I3, I4, I5, I6, I7, Self::IntoIter> {
4381 Iter9::I8(self.into_iter())
4382 }
4383 }
4384 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8> Iterator
4385 for Iter9<I0, I1, I2, I3, I4, I5, I6, I7, I8>
4386 where
4387 I0: Iterator<Item = Item>,
4388 I1: Iterator<Item = Item>,
4389 I2: Iterator<Item = Item>,
4390 I3: Iterator<Item = Item>,
4391 I4: Iterator<Item = Item>,
4392 I5: Iterator<Item = Item>,
4393 I6: Iterator<Item = Item>,
4394 I7: Iterator<Item = Item>,
4395 I8: Iterator<Item = Item>,
4396 {
4397 type Item = Item;
4398 fn next(&mut self) -> Option<Self::Item> {
4399 match self {
4400 Self::I0(this) => this.next(),
4401 Self::I1(this) => this.next(),
4402 Self::I2(this) => this.next(),
4403 Self::I3(this) => this.next(),
4404 Self::I4(this) => this.next(),
4405 Self::I5(this) => this.next(),
4406 Self::I6(this) => this.next(),
4407 Self::I7(this) => this.next(),
4408 Self::I8(this) => this.next(),
4409 }
4410 }
4411 fn size_hint(&self) -> (usize, Option<usize>) {
4412 match self {
4413 Self::I0(this) => this.size_hint(),
4414 Self::I1(this) => this.size_hint(),
4415 Self::I2(this) => this.size_hint(),
4416 Self::I3(this) => this.size_hint(),
4417 Self::I4(this) => this.size_hint(),
4418 Self::I5(this) => this.size_hint(),
4419 Self::I6(this) => this.size_hint(),
4420 Self::I7(this) => this.size_hint(),
4421 Self::I8(this) => this.size_hint(),
4422 }
4423 }
4424 fn count(self) -> usize
4425 where
4426 Self: Sized,
4427 {
4428 match self {
4429 Self::I0(this) => this.count(),
4430 Self::I1(this) => this.count(),
4431 Self::I2(this) => this.count(),
4432 Self::I3(this) => this.count(),
4433 Self::I4(this) => this.count(),
4434 Self::I5(this) => this.count(),
4435 Self::I6(this) => this.count(),
4436 Self::I7(this) => this.count(),
4437 Self::I8(this) => this.count(),
4438 }
4439 }
4440 fn last(self) -> Option<Self::Item>
4441 where
4442 Self: Sized,
4443 {
4444 match self {
4445 Self::I0(this) => this.last(),
4446 Self::I1(this) => this.last(),
4447 Self::I2(this) => this.last(),
4448 Self::I3(this) => this.last(),
4449 Self::I4(this) => this.last(),
4450 Self::I5(this) => this.last(),
4451 Self::I6(this) => this.last(),
4452 Self::I7(this) => this.last(),
4453 Self::I8(this) => this.last(),
4454 }
4455 }
4456 fn nth(&mut self, n: usize) -> Option<Self::Item> {
4457 match self {
4458 Self::I0(this) => this.nth(n),
4459 Self::I1(this) => this.nth(n),
4460 Self::I2(this) => this.nth(n),
4461 Self::I3(this) => this.nth(n),
4462 Self::I4(this) => this.nth(n),
4463 Self::I5(this) => this.nth(n),
4464 Self::I6(this) => this.nth(n),
4465 Self::I7(this) => this.nth(n),
4466 Self::I8(this) => this.nth(n),
4467 }
4468 }
4469 fn for_each<F>(self, f: F)
4470 where
4471 Self: Sized,
4472 F: FnMut(Self::Item),
4473 {
4474 match self {
4475 Self::I0(this) => this.for_each(f),
4476 Self::I1(this) => this.for_each(f),
4477 Self::I2(this) => this.for_each(f),
4478 Self::I3(this) => this.for_each(f),
4479 Self::I4(this) => this.for_each(f),
4480 Self::I5(this) => this.for_each(f),
4481 Self::I6(this) => this.for_each(f),
4482 Self::I7(this) => this.for_each(f),
4483 Self::I8(this) => this.for_each(f),
4484 }
4485 }
4486 fn collect<B: FromIterator<Self::Item>>(self) -> B
4487 where
4488 Self: Sized,
4489 {
4490 match self {
4491 Self::I0(this) => this.collect(),
4492 Self::I1(this) => this.collect(),
4493 Self::I2(this) => this.collect(),
4494 Self::I3(this) => this.collect(),
4495 Self::I4(this) => this.collect(),
4496 Self::I5(this) => this.collect(),
4497 Self::I6(this) => this.collect(),
4498 Self::I7(this) => this.collect(),
4499 Self::I8(this) => this.collect(),
4500 }
4501 }
4502 fn partition<B, F>(self, f: F) -> (B, B)
4503 where
4504 Self: Sized,
4505 B: Default + Extend<Self::Item>,
4506 F: FnMut(&Self::Item) -> bool,
4507 {
4508 match self {
4509 Self::I0(this) => this.partition(f),
4510 Self::I1(this) => this.partition(f),
4511 Self::I2(this) => this.partition(f),
4512 Self::I3(this) => this.partition(f),
4513 Self::I4(this) => this.partition(f),
4514 Self::I5(this) => this.partition(f),
4515 Self::I6(this) => this.partition(f),
4516 Self::I7(this) => this.partition(f),
4517 Self::I8(this) => this.partition(f),
4518 }
4519 }
4520 fn fold<B, F>(self, init: B, f: F) -> B
4521 where
4522 Self: Sized,
4523 F: FnMut(B, Self::Item) -> B,
4524 {
4525 match self {
4526 Self::I0(this) => this.fold(init, f),
4527 Self::I1(this) => this.fold(init, f),
4528 Self::I2(this) => this.fold(init, f),
4529 Self::I3(this) => this.fold(init, f),
4530 Self::I4(this) => this.fold(init, f),
4531 Self::I5(this) => this.fold(init, f),
4532 Self::I6(this) => this.fold(init, f),
4533 Self::I7(this) => this.fold(init, f),
4534 Self::I8(this) => this.fold(init, f),
4535 }
4536 }
4537 fn reduce<F>(self, f: F) -> Option<Self::Item>
4538 where
4539 Self: Sized,
4540 F: FnMut(Self::Item, Self::Item) -> Self::Item,
4541 {
4542 match self {
4543 Self::I0(this) => this.reduce(f),
4544 Self::I1(this) => this.reduce(f),
4545 Self::I2(this) => this.reduce(f),
4546 Self::I3(this) => this.reduce(f),
4547 Self::I4(this) => this.reduce(f),
4548 Self::I5(this) => this.reduce(f),
4549 Self::I6(this) => this.reduce(f),
4550 Self::I7(this) => this.reduce(f),
4551 Self::I8(this) => this.reduce(f),
4552 }
4553 }
4554 fn all<F>(&mut self, f: F) -> bool
4555 where
4556 Self: Sized,
4557 F: FnMut(Self::Item) -> bool,
4558 {
4559 match self {
4560 Self::I0(this) => this.all(f),
4561 Self::I1(this) => this.all(f),
4562 Self::I2(this) => this.all(f),
4563 Self::I3(this) => this.all(f),
4564 Self::I4(this) => this.all(f),
4565 Self::I5(this) => this.all(f),
4566 Self::I6(this) => this.all(f),
4567 Self::I7(this) => this.all(f),
4568 Self::I8(this) => this.all(f),
4569 }
4570 }
4571 fn any<F>(&mut self, f: F) -> bool
4572 where
4573 Self: Sized,
4574 F: FnMut(Self::Item) -> bool,
4575 {
4576 match self {
4577 Self::I0(this) => this.any(f),
4578 Self::I1(this) => this.any(f),
4579 Self::I2(this) => this.any(f),
4580 Self::I3(this) => this.any(f),
4581 Self::I4(this) => this.any(f),
4582 Self::I5(this) => this.any(f),
4583 Self::I6(this) => this.any(f),
4584 Self::I7(this) => this.any(f),
4585 Self::I8(this) => this.any(f),
4586 }
4587 }
4588 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
4589 where
4590 Self: Sized,
4591 P: FnMut(&Self::Item) -> bool,
4592 {
4593 match self {
4594 Self::I0(this) => this.find(predicate),
4595 Self::I1(this) => this.find(predicate),
4596 Self::I2(this) => this.find(predicate),
4597 Self::I3(this) => this.find(predicate),
4598 Self::I4(this) => this.find(predicate),
4599 Self::I5(this) => this.find(predicate),
4600 Self::I6(this) => this.find(predicate),
4601 Self::I7(this) => this.find(predicate),
4602 Self::I8(this) => this.find(predicate),
4603 }
4604 }
4605 fn find_map<B, F>(&mut self, f: F) -> Option<B>
4606 where
4607 Self: Sized,
4608 F: FnMut(Self::Item) -> Option<B>,
4609 {
4610 match self {
4611 Self::I0(this) => this.find_map(f),
4612 Self::I1(this) => this.find_map(f),
4613 Self::I2(this) => this.find_map(f),
4614 Self::I3(this) => this.find_map(f),
4615 Self::I4(this) => this.find_map(f),
4616 Self::I5(this) => this.find_map(f),
4617 Self::I6(this) => this.find_map(f),
4618 Self::I7(this) => this.find_map(f),
4619 Self::I8(this) => this.find_map(f),
4620 }
4621 }
4622 fn position<P>(&mut self, predicate: P) -> Option<usize>
4623 where
4624 Self: Sized,
4625 P: FnMut(Self::Item) -> bool,
4626 {
4627 match self {
4628 Self::I0(this) => this.position(predicate),
4629 Self::I1(this) => this.position(predicate),
4630 Self::I2(this) => this.position(predicate),
4631 Self::I3(this) => this.position(predicate),
4632 Self::I4(this) => this.position(predicate),
4633 Self::I5(this) => this.position(predicate),
4634 Self::I6(this) => this.position(predicate),
4635 Self::I7(this) => this.position(predicate),
4636 Self::I8(this) => this.position(predicate),
4637 }
4638 }
4639 fn max(self) -> Option<Self::Item>
4640 where
4641 Self: Sized,
4642 Self::Item: Ord,
4643 {
4644 match self {
4645 Self::I0(this) => this.max(),
4646 Self::I1(this) => this.max(),
4647 Self::I2(this) => this.max(),
4648 Self::I3(this) => this.max(),
4649 Self::I4(this) => this.max(),
4650 Self::I5(this) => this.max(),
4651 Self::I6(this) => this.max(),
4652 Self::I7(this) => this.max(),
4653 Self::I8(this) => this.max(),
4654 }
4655 }
4656 fn min(self) -> Option<Self::Item>
4657 where
4658 Self: Sized,
4659 Self::Item: Ord,
4660 {
4661 match self {
4662 Self::I0(this) => this.min(),
4663 Self::I1(this) => this.min(),
4664 Self::I2(this) => this.min(),
4665 Self::I3(this) => this.min(),
4666 Self::I4(this) => this.min(),
4667 Self::I5(this) => this.min(),
4668 Self::I6(this) => this.min(),
4669 Self::I7(this) => this.min(),
4670 Self::I8(this) => this.min(),
4671 }
4672 }
4673 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
4674 where
4675 Self: Sized,
4676 F: FnMut(&Self::Item) -> B,
4677 {
4678 match self {
4679 Self::I0(this) => this.max_by_key(f),
4680 Self::I1(this) => this.max_by_key(f),
4681 Self::I2(this) => this.max_by_key(f),
4682 Self::I3(this) => this.max_by_key(f),
4683 Self::I4(this) => this.max_by_key(f),
4684 Self::I5(this) => this.max_by_key(f),
4685 Self::I6(this) => this.max_by_key(f),
4686 Self::I7(this) => this.max_by_key(f),
4687 Self::I8(this) => this.max_by_key(f),
4688 }
4689 }
4690 fn max_by<F>(self, compare: F) -> Option<Self::Item>
4691 where
4692 Self: Sized,
4693 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
4694 {
4695 match self {
4696 Self::I0(this) => this.max_by(compare),
4697 Self::I1(this) => this.max_by(compare),
4698 Self::I2(this) => this.max_by(compare),
4699 Self::I3(this) => this.max_by(compare),
4700 Self::I4(this) => this.max_by(compare),
4701 Self::I5(this) => this.max_by(compare),
4702 Self::I6(this) => this.max_by(compare),
4703 Self::I7(this) => this.max_by(compare),
4704 Self::I8(this) => this.max_by(compare),
4705 }
4706 }
4707 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
4708 where
4709 Self: Sized,
4710 F: FnMut(&Self::Item) -> B,
4711 {
4712 match self {
4713 Self::I0(this) => this.min_by_key(f),
4714 Self::I1(this) => this.min_by_key(f),
4715 Self::I2(this) => this.min_by_key(f),
4716 Self::I3(this) => this.min_by_key(f),
4717 Self::I4(this) => this.min_by_key(f),
4718 Self::I5(this) => this.min_by_key(f),
4719 Self::I6(this) => this.min_by_key(f),
4720 Self::I7(this) => this.min_by_key(f),
4721 Self::I8(this) => this.min_by_key(f),
4722 }
4723 }
4724 fn min_by<F>(self, compare: F) -> Option<Self::Item>
4725 where
4726 Self: Sized,
4727 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
4728 {
4729 match self {
4730 Self::I0(this) => this.min_by(compare),
4731 Self::I1(this) => this.min_by(compare),
4732 Self::I2(this) => this.min_by(compare),
4733 Self::I3(this) => this.min_by(compare),
4734 Self::I4(this) => this.min_by(compare),
4735 Self::I5(this) => this.min_by(compare),
4736 Self::I6(this) => this.min_by(compare),
4737 Self::I7(this) => this.min_by(compare),
4738 Self::I8(this) => this.min_by(compare),
4739 }
4740 }
4741 fn sum<S>(self) -> S
4742 where
4743 Self: Sized,
4744 S: Sum<Self::Item>,
4745 {
4746 match self {
4747 Self::I0(this) => this.sum(),
4748 Self::I1(this) => this.sum(),
4749 Self::I2(this) => this.sum(),
4750 Self::I3(this) => this.sum(),
4751 Self::I4(this) => this.sum(),
4752 Self::I5(this) => this.sum(),
4753 Self::I6(this) => this.sum(),
4754 Self::I7(this) => this.sum(),
4755 Self::I8(this) => this.sum(),
4756 }
4757 }
4758 fn product<P>(self) -> P
4759 where
4760 Self: Sized,
4761 P: Product<Self::Item>,
4762 {
4763 match self {
4764 Self::I0(this) => this.product(),
4765 Self::I1(this) => this.product(),
4766 Self::I2(this) => this.product(),
4767 Self::I3(this) => this.product(),
4768 Self::I4(this) => this.product(),
4769 Self::I5(this) => this.product(),
4770 Self::I6(this) => this.product(),
4771 Self::I7(this) => this.product(),
4772 Self::I8(this) => this.product(),
4773 }
4774 }
4775 fn cmp<I>(self, other: I) -> Ordering
4776 where
4777 I: IntoIterator<Item = Self::Item>,
4778 Self::Item: Ord,
4779 Self: Sized,
4780 {
4781 match self {
4782 Self::I0(this) => this.cmp(other),
4783 Self::I1(this) => this.cmp(other),
4784 Self::I2(this) => this.cmp(other),
4785 Self::I3(this) => this.cmp(other),
4786 Self::I4(this) => this.cmp(other),
4787 Self::I5(this) => this.cmp(other),
4788 Self::I6(this) => this.cmp(other),
4789 Self::I7(this) => this.cmp(other),
4790 Self::I8(this) => this.cmp(other),
4791 }
4792 }
4793 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
4794 where
4795 I: IntoIterator,
4796 Self::Item: PartialOrd<I::Item>,
4797 Self: Sized,
4798 {
4799 match self {
4800 Self::I0(this) => this.partial_cmp(other),
4801 Self::I1(this) => this.partial_cmp(other),
4802 Self::I2(this) => this.partial_cmp(other),
4803 Self::I3(this) => this.partial_cmp(other),
4804 Self::I4(this) => this.partial_cmp(other),
4805 Self::I5(this) => this.partial_cmp(other),
4806 Self::I6(this) => this.partial_cmp(other),
4807 Self::I7(this) => this.partial_cmp(other),
4808 Self::I8(this) => this.partial_cmp(other),
4809 }
4810 }
4811 fn eq<I>(self, other: I) -> bool
4812 where
4813 I: IntoIterator,
4814 Self::Item: PartialEq<I::Item>,
4815 Self: Sized,
4816 {
4817 match self {
4818 Self::I0(this) => this.eq(other),
4819 Self::I1(this) => this.eq(other),
4820 Self::I2(this) => this.eq(other),
4821 Self::I3(this) => this.eq(other),
4822 Self::I4(this) => this.eq(other),
4823 Self::I5(this) => this.eq(other),
4824 Self::I6(this) => this.eq(other),
4825 Self::I7(this) => this.eq(other),
4826 Self::I8(this) => this.eq(other),
4827 }
4828 }
4829 fn ne<I>(self, other: I) -> bool
4830 where
4831 I: IntoIterator,
4832 Self::Item: PartialEq<I::Item>,
4833 Self: Sized,
4834 {
4835 match self {
4836 Self::I0(this) => this.ne(other),
4837 Self::I1(this) => this.ne(other),
4838 Self::I2(this) => this.ne(other),
4839 Self::I3(this) => this.ne(other),
4840 Self::I4(this) => this.ne(other),
4841 Self::I5(this) => this.ne(other),
4842 Self::I6(this) => this.ne(other),
4843 Self::I7(this) => this.ne(other),
4844 Self::I8(this) => this.ne(other),
4845 }
4846 }
4847 fn lt<I>(self, other: I) -> bool
4848 where
4849 I: IntoIterator,
4850 Self::Item: PartialOrd<I::Item>,
4851 Self: Sized,
4852 {
4853 match self {
4854 Self::I0(this) => this.lt(other),
4855 Self::I1(this) => this.lt(other),
4856 Self::I2(this) => this.lt(other),
4857 Self::I3(this) => this.lt(other),
4858 Self::I4(this) => this.lt(other),
4859 Self::I5(this) => this.lt(other),
4860 Self::I6(this) => this.lt(other),
4861 Self::I7(this) => this.lt(other),
4862 Self::I8(this) => this.lt(other),
4863 }
4864 }
4865 fn le<I>(self, other: I) -> bool
4866 where
4867 I: IntoIterator,
4868 Self::Item: PartialOrd<I::Item>,
4869 Self: Sized,
4870 {
4871 match self {
4872 Self::I0(this) => this.le(other),
4873 Self::I1(this) => this.le(other),
4874 Self::I2(this) => this.le(other),
4875 Self::I3(this) => this.le(other),
4876 Self::I4(this) => this.le(other),
4877 Self::I5(this) => this.le(other),
4878 Self::I6(this) => this.le(other),
4879 Self::I7(this) => this.le(other),
4880 Self::I8(this) => this.le(other),
4881 }
4882 }
4883 fn gt<I>(self, other: I) -> bool
4884 where
4885 I: IntoIterator,
4886 Self::Item: PartialOrd<I::Item>,
4887 Self: Sized,
4888 {
4889 match self {
4890 Self::I0(this) => this.gt(other),
4891 Self::I1(this) => this.gt(other),
4892 Self::I2(this) => this.gt(other),
4893 Self::I3(this) => this.gt(other),
4894 Self::I4(this) => this.gt(other),
4895 Self::I5(this) => this.gt(other),
4896 Self::I6(this) => this.gt(other),
4897 Self::I7(this) => this.gt(other),
4898 Self::I8(this) => this.gt(other),
4899 }
4900 }
4901 fn ge<I>(self, other: I) -> bool
4902 where
4903 I: IntoIterator,
4904 Self::Item: PartialOrd<I::Item>,
4905 Self: Sized,
4906 {
4907 match self {
4908 Self::I0(this) => this.ge(other),
4909 Self::I1(this) => this.ge(other),
4910 Self::I2(this) => this.ge(other),
4911 Self::I3(this) => this.ge(other),
4912 Self::I4(this) => this.ge(other),
4913 Self::I5(this) => this.ge(other),
4914 Self::I6(this) => this.ge(other),
4915 Self::I7(this) => this.ge(other),
4916 Self::I8(this) => this.ge(other),
4917 }
4918 }
4919 }
4920 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8> DoubleEndedIterator
4921 for Iter9<I0, I1, I2, I3, I4, I5, I6, I7, I8>
4922 where
4923 I0: DoubleEndedIterator<Item = Item>,
4924 I1: DoubleEndedIterator<Item = Item>,
4925 I2: DoubleEndedIterator<Item = Item>,
4926 I3: DoubleEndedIterator<Item = Item>,
4927 I4: DoubleEndedIterator<Item = Item>,
4928 I5: DoubleEndedIterator<Item = Item>,
4929 I6: DoubleEndedIterator<Item = Item>,
4930 I7: DoubleEndedIterator<Item = Item>,
4931 I8: DoubleEndedIterator<Item = Item>,
4932 {
4933 fn next_back(&mut self) -> Option<Self::Item> {
4934 match self {
4935 Self::I0(this) => this.next_back(),
4936 Self::I1(this) => this.next_back(),
4937 Self::I2(this) => this.next_back(),
4938 Self::I3(this) => this.next_back(),
4939 Self::I4(this) => this.next_back(),
4940 Self::I5(this) => this.next_back(),
4941 Self::I6(this) => this.next_back(),
4942 Self::I7(this) => this.next_back(),
4943 Self::I8(this) => this.next_back(),
4944 }
4945 }
4946 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
4947 match self {
4948 Self::I0(this) => this.nth_back(n),
4949 Self::I1(this) => this.nth_back(n),
4950 Self::I2(this) => this.nth_back(n),
4951 Self::I3(this) => this.nth_back(n),
4952 Self::I4(this) => this.nth_back(n),
4953 Self::I5(this) => this.nth_back(n),
4954 Self::I6(this) => this.nth_back(n),
4955 Self::I7(this) => this.nth_back(n),
4956 Self::I8(this) => this.nth_back(n),
4957 }
4958 }
4959 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
4960 where
4961 P: FnMut(&Self::Item) -> bool,
4962 {
4963 match self {
4964 Self::I0(this) => this.rfind(predicate),
4965 Self::I1(this) => this.rfind(predicate),
4966 Self::I2(this) => this.rfind(predicate),
4967 Self::I3(this) => this.rfind(predicate),
4968 Self::I4(this) => this.rfind(predicate),
4969 Self::I5(this) => this.rfind(predicate),
4970 Self::I6(this) => this.rfind(predicate),
4971 Self::I7(this) => this.rfind(predicate),
4972 Self::I8(this) => this.rfind(predicate),
4973 }
4974 }
4975 fn rfold<B, F>(self, init: B, f: F) -> B
4976 where
4977 Self: Sized,
4978 F: FnMut(B, Self::Item) -> B,
4979 {
4980 match self {
4981 Self::I0(this) => this.rfold(init, f),
4982 Self::I1(this) => this.rfold(init, f),
4983 Self::I2(this) => this.rfold(init, f),
4984 Self::I3(this) => this.rfold(init, f),
4985 Self::I4(this) => this.rfold(init, f),
4986 Self::I5(this) => this.rfold(init, f),
4987 Self::I6(this) => this.rfold(init, f),
4988 Self::I7(this) => this.rfold(init, f),
4989 Self::I8(this) => this.rfold(init, f),
4990 }
4991 }
4992 }
4993 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8> ExactSizeIterator
4994 for Iter9<I0, I1, I2, I3, I4, I5, I6, I7, I8>
4995 where
4996 I0: ExactSizeIterator<Item = Item>,
4997 I1: ExactSizeIterator<Item = Item>,
4998 I2: ExactSizeIterator<Item = Item>,
4999 I3: ExactSizeIterator<Item = Item>,
5000 I4: ExactSizeIterator<Item = Item>,
5001 I5: ExactSizeIterator<Item = Item>,
5002 I6: ExactSizeIterator<Item = Item>,
5003 I7: ExactSizeIterator<Item = Item>,
5004 I8: ExactSizeIterator<Item = Item>,
5005 {
5006 fn len(&self) -> usize {
5007 match self {
5008 Self::I0(this) => this.len(),
5009 Self::I1(this) => this.len(),
5010 Self::I2(this) => this.len(),
5011 Self::I3(this) => this.len(),
5012 Self::I4(this) => this.len(),
5013 Self::I5(this) => this.len(),
5014 Self::I6(this) => this.len(),
5015 Self::I7(this) => this.len(),
5016 Self::I8(this) => this.len(),
5017 }
5018 }
5019 }
5020 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8> FusedIterator
5021 for Iter9<I0, I1, I2, I3, I4, I5, I6, I7, I8>
5022 where
5023 I0: FusedIterator<Item = Item>,
5024 I1: FusedIterator<Item = Item>,
5025 I2: FusedIterator<Item = Item>,
5026 I3: FusedIterator<Item = Item>,
5027 I4: FusedIterator<Item = Item>,
5028 I5: FusedIterator<Item = Item>,
5029 I6: FusedIterator<Item = Item>,
5030 I7: FusedIterator<Item = Item>,
5031 I8: FusedIterator<Item = Item>,
5032 {
5033 }
5034}
5035pub mod iter10 {
5036 use super::*;
5037 use core::iter::FusedIterator;
5038 #[derive(Debug, Clone, Copy)]
5039 pub enum Iter10<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9> {
5040 I0(I0),
5041 I1(I1),
5042 I2(I2),
5043 I3(I3),
5044 I4(I4),
5045 I5(I5),
5046 I6(I6),
5047 I7(I7),
5048 I8(I8),
5049 I9(I9),
5050 }
5051 pub trait IntoIter0: IntoIterator {
5052 #[allow(clippy::type_complexity)]
5053 fn into_iter0<I1, I2, I3, I4, I5, I6, I7, I8, I9>(
5054 self,
5055 ) -> Iter10<Self::IntoIter, I1, I2, I3, I4, I5, I6, I7, I8, I9>;
5056 }
5057 impl<T: IntoIterator> IntoIter0 for T {
5058 #[allow(clippy::type_complexity)]
5059 fn into_iter0<I1, I2, I3, I4, I5, I6, I7, I8, I9>(
5060 self,
5061 ) -> Iter10<Self::IntoIter, I1, I2, I3, I4, I5, I6, I7, I8, I9> {
5062 Iter10::I0(self.into_iter())
5063 }
5064 }
5065 pub trait IntoIter1: IntoIterator {
5066 #[allow(clippy::type_complexity)]
5067 fn into_iter1<I0, I2, I3, I4, I5, I6, I7, I8, I9>(
5068 self,
5069 ) -> Iter10<I0, Self::IntoIter, I2, I3, I4, I5, I6, I7, I8, I9>;
5070 }
5071 impl<T: IntoIterator> IntoIter1 for T {
5072 #[allow(clippy::type_complexity)]
5073 fn into_iter1<I0, I2, I3, I4, I5, I6, I7, I8, I9>(
5074 self,
5075 ) -> Iter10<I0, Self::IntoIter, I2, I3, I4, I5, I6, I7, I8, I9> {
5076 Iter10::I1(self.into_iter())
5077 }
5078 }
5079 pub trait IntoIter2: IntoIterator {
5080 #[allow(clippy::type_complexity)]
5081 fn into_iter2<I0, I1, I3, I4, I5, I6, I7, I8, I9>(
5082 self,
5083 ) -> Iter10<I0, I1, Self::IntoIter, I3, I4, I5, I6, I7, I8, I9>;
5084 }
5085 impl<T: IntoIterator> IntoIter2 for T {
5086 #[allow(clippy::type_complexity)]
5087 fn into_iter2<I0, I1, I3, I4, I5, I6, I7, I8, I9>(
5088 self,
5089 ) -> Iter10<I0, I1, Self::IntoIter, I3, I4, I5, I6, I7, I8, I9> {
5090 Iter10::I2(self.into_iter())
5091 }
5092 }
5093 pub trait IntoIter3: IntoIterator {
5094 #[allow(clippy::type_complexity)]
5095 fn into_iter3<I0, I1, I2, I4, I5, I6, I7, I8, I9>(
5096 self,
5097 ) -> Iter10<I0, I1, I2, Self::IntoIter, I4, I5, I6, I7, I8, I9>;
5098 }
5099 impl<T: IntoIterator> IntoIter3 for T {
5100 #[allow(clippy::type_complexity)]
5101 fn into_iter3<I0, I1, I2, I4, I5, I6, I7, I8, I9>(
5102 self,
5103 ) -> Iter10<I0, I1, I2, Self::IntoIter, I4, I5, I6, I7, I8, I9> {
5104 Iter10::I3(self.into_iter())
5105 }
5106 }
5107 pub trait IntoIter4: IntoIterator {
5108 #[allow(clippy::type_complexity)]
5109 fn into_iter4<I0, I1, I2, I3, I5, I6, I7, I8, I9>(
5110 self,
5111 ) -> Iter10<I0, I1, I2, I3, Self::IntoIter, I5, I6, I7, I8, I9>;
5112 }
5113 impl<T: IntoIterator> IntoIter4 for T {
5114 #[allow(clippy::type_complexity)]
5115 fn into_iter4<I0, I1, I2, I3, I5, I6, I7, I8, I9>(
5116 self,
5117 ) -> Iter10<I0, I1, I2, I3, Self::IntoIter, I5, I6, I7, I8, I9> {
5118 Iter10::I4(self.into_iter())
5119 }
5120 }
5121 pub trait IntoIter5: IntoIterator {
5122 #[allow(clippy::type_complexity)]
5123 fn into_iter5<I0, I1, I2, I3, I4, I6, I7, I8, I9>(
5124 self,
5125 ) -> Iter10<I0, I1, I2, I3, I4, Self::IntoIter, I6, I7, I8, I9>;
5126 }
5127 impl<T: IntoIterator> IntoIter5 for T {
5128 #[allow(clippy::type_complexity)]
5129 fn into_iter5<I0, I1, I2, I3, I4, I6, I7, I8, I9>(
5130 self,
5131 ) -> Iter10<I0, I1, I2, I3, I4, Self::IntoIter, I6, I7, I8, I9> {
5132 Iter10::I5(self.into_iter())
5133 }
5134 }
5135 pub trait IntoIter6: IntoIterator {
5136 #[allow(clippy::type_complexity)]
5137 fn into_iter6<I0, I1, I2, I3, I4, I5, I7, I8, I9>(
5138 self,
5139 ) -> Iter10<I0, I1, I2, I3, I4, I5, Self::IntoIter, I7, I8, I9>;
5140 }
5141 impl<T: IntoIterator> IntoIter6 for T {
5142 #[allow(clippy::type_complexity)]
5143 fn into_iter6<I0, I1, I2, I3, I4, I5, I7, I8, I9>(
5144 self,
5145 ) -> Iter10<I0, I1, I2, I3, I4, I5, Self::IntoIter, I7, I8, I9> {
5146 Iter10::I6(self.into_iter())
5147 }
5148 }
5149 pub trait IntoIter7: IntoIterator {
5150 #[allow(clippy::type_complexity)]
5151 fn into_iter7<I0, I1, I2, I3, I4, I5, I6, I8, I9>(
5152 self,
5153 ) -> Iter10<I0, I1, I2, I3, I4, I5, I6, Self::IntoIter, I8, I9>;
5154 }
5155 impl<T: IntoIterator> IntoIter7 for T {
5156 #[allow(clippy::type_complexity)]
5157 fn into_iter7<I0, I1, I2, I3, I4, I5, I6, I8, I9>(
5158 self,
5159 ) -> Iter10<I0, I1, I2, I3, I4, I5, I6, Self::IntoIter, I8, I9> {
5160 Iter10::I7(self.into_iter())
5161 }
5162 }
5163 pub trait IntoIter8: IntoIterator {
5164 #[allow(clippy::type_complexity)]
5165 fn into_iter8<I0, I1, I2, I3, I4, I5, I6, I7, I9>(
5166 self,
5167 ) -> Iter10<I0, I1, I2, I3, I4, I5, I6, I7, Self::IntoIter, I9>;
5168 }
5169 impl<T: IntoIterator> IntoIter8 for T {
5170 #[allow(clippy::type_complexity)]
5171 fn into_iter8<I0, I1, I2, I3, I4, I5, I6, I7, I9>(
5172 self,
5173 ) -> Iter10<I0, I1, I2, I3, I4, I5, I6, I7, Self::IntoIter, I9> {
5174 Iter10::I8(self.into_iter())
5175 }
5176 }
5177 pub trait IntoIter9: IntoIterator {
5178 #[allow(clippy::type_complexity)]
5179 fn into_iter9<I0, I1, I2, I3, I4, I5, I6, I7, I8>(
5180 self,
5181 ) -> Iter10<I0, I1, I2, I3, I4, I5, I6, I7, I8, Self::IntoIter>;
5182 }
5183 impl<T: IntoIterator> IntoIter9 for T {
5184 #[allow(clippy::type_complexity)]
5185 fn into_iter9<I0, I1, I2, I3, I4, I5, I6, I7, I8>(
5186 self,
5187 ) -> Iter10<I0, I1, I2, I3, I4, I5, I6, I7, I8, Self::IntoIter> {
5188 Iter10::I9(self.into_iter())
5189 }
5190 }
5191 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9> Iterator
5192 for Iter10<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9>
5193 where
5194 I0: Iterator<Item = Item>,
5195 I1: Iterator<Item = Item>,
5196 I2: Iterator<Item = Item>,
5197 I3: Iterator<Item = Item>,
5198 I4: Iterator<Item = Item>,
5199 I5: Iterator<Item = Item>,
5200 I6: Iterator<Item = Item>,
5201 I7: Iterator<Item = Item>,
5202 I8: Iterator<Item = Item>,
5203 I9: Iterator<Item = Item>,
5204 {
5205 type Item = Item;
5206 fn next(&mut self) -> Option<Self::Item> {
5207 match self {
5208 Self::I0(this) => this.next(),
5209 Self::I1(this) => this.next(),
5210 Self::I2(this) => this.next(),
5211 Self::I3(this) => this.next(),
5212 Self::I4(this) => this.next(),
5213 Self::I5(this) => this.next(),
5214 Self::I6(this) => this.next(),
5215 Self::I7(this) => this.next(),
5216 Self::I8(this) => this.next(),
5217 Self::I9(this) => this.next(),
5218 }
5219 }
5220 fn size_hint(&self) -> (usize, Option<usize>) {
5221 match self {
5222 Self::I0(this) => this.size_hint(),
5223 Self::I1(this) => this.size_hint(),
5224 Self::I2(this) => this.size_hint(),
5225 Self::I3(this) => this.size_hint(),
5226 Self::I4(this) => this.size_hint(),
5227 Self::I5(this) => this.size_hint(),
5228 Self::I6(this) => this.size_hint(),
5229 Self::I7(this) => this.size_hint(),
5230 Self::I8(this) => this.size_hint(),
5231 Self::I9(this) => this.size_hint(),
5232 }
5233 }
5234 fn count(self) -> usize
5235 where
5236 Self: Sized,
5237 {
5238 match self {
5239 Self::I0(this) => this.count(),
5240 Self::I1(this) => this.count(),
5241 Self::I2(this) => this.count(),
5242 Self::I3(this) => this.count(),
5243 Self::I4(this) => this.count(),
5244 Self::I5(this) => this.count(),
5245 Self::I6(this) => this.count(),
5246 Self::I7(this) => this.count(),
5247 Self::I8(this) => this.count(),
5248 Self::I9(this) => this.count(),
5249 }
5250 }
5251 fn last(self) -> Option<Self::Item>
5252 where
5253 Self: Sized,
5254 {
5255 match self {
5256 Self::I0(this) => this.last(),
5257 Self::I1(this) => this.last(),
5258 Self::I2(this) => this.last(),
5259 Self::I3(this) => this.last(),
5260 Self::I4(this) => this.last(),
5261 Self::I5(this) => this.last(),
5262 Self::I6(this) => this.last(),
5263 Self::I7(this) => this.last(),
5264 Self::I8(this) => this.last(),
5265 Self::I9(this) => this.last(),
5266 }
5267 }
5268 fn nth(&mut self, n: usize) -> Option<Self::Item> {
5269 match self {
5270 Self::I0(this) => this.nth(n),
5271 Self::I1(this) => this.nth(n),
5272 Self::I2(this) => this.nth(n),
5273 Self::I3(this) => this.nth(n),
5274 Self::I4(this) => this.nth(n),
5275 Self::I5(this) => this.nth(n),
5276 Self::I6(this) => this.nth(n),
5277 Self::I7(this) => this.nth(n),
5278 Self::I8(this) => this.nth(n),
5279 Self::I9(this) => this.nth(n),
5280 }
5281 }
5282 fn for_each<F>(self, f: F)
5283 where
5284 Self: Sized,
5285 F: FnMut(Self::Item),
5286 {
5287 match self {
5288 Self::I0(this) => this.for_each(f),
5289 Self::I1(this) => this.for_each(f),
5290 Self::I2(this) => this.for_each(f),
5291 Self::I3(this) => this.for_each(f),
5292 Self::I4(this) => this.for_each(f),
5293 Self::I5(this) => this.for_each(f),
5294 Self::I6(this) => this.for_each(f),
5295 Self::I7(this) => this.for_each(f),
5296 Self::I8(this) => this.for_each(f),
5297 Self::I9(this) => this.for_each(f),
5298 }
5299 }
5300 fn collect<B: FromIterator<Self::Item>>(self) -> B
5301 where
5302 Self: Sized,
5303 {
5304 match self {
5305 Self::I0(this) => this.collect(),
5306 Self::I1(this) => this.collect(),
5307 Self::I2(this) => this.collect(),
5308 Self::I3(this) => this.collect(),
5309 Self::I4(this) => this.collect(),
5310 Self::I5(this) => this.collect(),
5311 Self::I6(this) => this.collect(),
5312 Self::I7(this) => this.collect(),
5313 Self::I8(this) => this.collect(),
5314 Self::I9(this) => this.collect(),
5315 }
5316 }
5317 fn partition<B, F>(self, f: F) -> (B, B)
5318 where
5319 Self: Sized,
5320 B: Default + Extend<Self::Item>,
5321 F: FnMut(&Self::Item) -> bool,
5322 {
5323 match self {
5324 Self::I0(this) => this.partition(f),
5325 Self::I1(this) => this.partition(f),
5326 Self::I2(this) => this.partition(f),
5327 Self::I3(this) => this.partition(f),
5328 Self::I4(this) => this.partition(f),
5329 Self::I5(this) => this.partition(f),
5330 Self::I6(this) => this.partition(f),
5331 Self::I7(this) => this.partition(f),
5332 Self::I8(this) => this.partition(f),
5333 Self::I9(this) => this.partition(f),
5334 }
5335 }
5336 fn fold<B, F>(self, init: B, f: F) -> B
5337 where
5338 Self: Sized,
5339 F: FnMut(B, Self::Item) -> B,
5340 {
5341 match self {
5342 Self::I0(this) => this.fold(init, f),
5343 Self::I1(this) => this.fold(init, f),
5344 Self::I2(this) => this.fold(init, f),
5345 Self::I3(this) => this.fold(init, f),
5346 Self::I4(this) => this.fold(init, f),
5347 Self::I5(this) => this.fold(init, f),
5348 Self::I6(this) => this.fold(init, f),
5349 Self::I7(this) => this.fold(init, f),
5350 Self::I8(this) => this.fold(init, f),
5351 Self::I9(this) => this.fold(init, f),
5352 }
5353 }
5354 fn reduce<F>(self, f: F) -> Option<Self::Item>
5355 where
5356 Self: Sized,
5357 F: FnMut(Self::Item, Self::Item) -> Self::Item,
5358 {
5359 match self {
5360 Self::I0(this) => this.reduce(f),
5361 Self::I1(this) => this.reduce(f),
5362 Self::I2(this) => this.reduce(f),
5363 Self::I3(this) => this.reduce(f),
5364 Self::I4(this) => this.reduce(f),
5365 Self::I5(this) => this.reduce(f),
5366 Self::I6(this) => this.reduce(f),
5367 Self::I7(this) => this.reduce(f),
5368 Self::I8(this) => this.reduce(f),
5369 Self::I9(this) => this.reduce(f),
5370 }
5371 }
5372 fn all<F>(&mut self, f: F) -> bool
5373 where
5374 Self: Sized,
5375 F: FnMut(Self::Item) -> bool,
5376 {
5377 match self {
5378 Self::I0(this) => this.all(f),
5379 Self::I1(this) => this.all(f),
5380 Self::I2(this) => this.all(f),
5381 Self::I3(this) => this.all(f),
5382 Self::I4(this) => this.all(f),
5383 Self::I5(this) => this.all(f),
5384 Self::I6(this) => this.all(f),
5385 Self::I7(this) => this.all(f),
5386 Self::I8(this) => this.all(f),
5387 Self::I9(this) => this.all(f),
5388 }
5389 }
5390 fn any<F>(&mut self, f: F) -> bool
5391 where
5392 Self: Sized,
5393 F: FnMut(Self::Item) -> bool,
5394 {
5395 match self {
5396 Self::I0(this) => this.any(f),
5397 Self::I1(this) => this.any(f),
5398 Self::I2(this) => this.any(f),
5399 Self::I3(this) => this.any(f),
5400 Self::I4(this) => this.any(f),
5401 Self::I5(this) => this.any(f),
5402 Self::I6(this) => this.any(f),
5403 Self::I7(this) => this.any(f),
5404 Self::I8(this) => this.any(f),
5405 Self::I9(this) => this.any(f),
5406 }
5407 }
5408 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
5409 where
5410 Self: Sized,
5411 P: FnMut(&Self::Item) -> bool,
5412 {
5413 match self {
5414 Self::I0(this) => this.find(predicate),
5415 Self::I1(this) => this.find(predicate),
5416 Self::I2(this) => this.find(predicate),
5417 Self::I3(this) => this.find(predicate),
5418 Self::I4(this) => this.find(predicate),
5419 Self::I5(this) => this.find(predicate),
5420 Self::I6(this) => this.find(predicate),
5421 Self::I7(this) => this.find(predicate),
5422 Self::I8(this) => this.find(predicate),
5423 Self::I9(this) => this.find(predicate),
5424 }
5425 }
5426 fn find_map<B, F>(&mut self, f: F) -> Option<B>
5427 where
5428 Self: Sized,
5429 F: FnMut(Self::Item) -> Option<B>,
5430 {
5431 match self {
5432 Self::I0(this) => this.find_map(f),
5433 Self::I1(this) => this.find_map(f),
5434 Self::I2(this) => this.find_map(f),
5435 Self::I3(this) => this.find_map(f),
5436 Self::I4(this) => this.find_map(f),
5437 Self::I5(this) => this.find_map(f),
5438 Self::I6(this) => this.find_map(f),
5439 Self::I7(this) => this.find_map(f),
5440 Self::I8(this) => this.find_map(f),
5441 Self::I9(this) => this.find_map(f),
5442 }
5443 }
5444 fn position<P>(&mut self, predicate: P) -> Option<usize>
5445 where
5446 Self: Sized,
5447 P: FnMut(Self::Item) -> bool,
5448 {
5449 match self {
5450 Self::I0(this) => this.position(predicate),
5451 Self::I1(this) => this.position(predicate),
5452 Self::I2(this) => this.position(predicate),
5453 Self::I3(this) => this.position(predicate),
5454 Self::I4(this) => this.position(predicate),
5455 Self::I5(this) => this.position(predicate),
5456 Self::I6(this) => this.position(predicate),
5457 Self::I7(this) => this.position(predicate),
5458 Self::I8(this) => this.position(predicate),
5459 Self::I9(this) => this.position(predicate),
5460 }
5461 }
5462 fn max(self) -> Option<Self::Item>
5463 where
5464 Self: Sized,
5465 Self::Item: Ord,
5466 {
5467 match self {
5468 Self::I0(this) => this.max(),
5469 Self::I1(this) => this.max(),
5470 Self::I2(this) => this.max(),
5471 Self::I3(this) => this.max(),
5472 Self::I4(this) => this.max(),
5473 Self::I5(this) => this.max(),
5474 Self::I6(this) => this.max(),
5475 Self::I7(this) => this.max(),
5476 Self::I8(this) => this.max(),
5477 Self::I9(this) => this.max(),
5478 }
5479 }
5480 fn min(self) -> Option<Self::Item>
5481 where
5482 Self: Sized,
5483 Self::Item: Ord,
5484 {
5485 match self {
5486 Self::I0(this) => this.min(),
5487 Self::I1(this) => this.min(),
5488 Self::I2(this) => this.min(),
5489 Self::I3(this) => this.min(),
5490 Self::I4(this) => this.min(),
5491 Self::I5(this) => this.min(),
5492 Self::I6(this) => this.min(),
5493 Self::I7(this) => this.min(),
5494 Self::I8(this) => this.min(),
5495 Self::I9(this) => this.min(),
5496 }
5497 }
5498 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
5499 where
5500 Self: Sized,
5501 F: FnMut(&Self::Item) -> B,
5502 {
5503 match self {
5504 Self::I0(this) => this.max_by_key(f),
5505 Self::I1(this) => this.max_by_key(f),
5506 Self::I2(this) => this.max_by_key(f),
5507 Self::I3(this) => this.max_by_key(f),
5508 Self::I4(this) => this.max_by_key(f),
5509 Self::I5(this) => this.max_by_key(f),
5510 Self::I6(this) => this.max_by_key(f),
5511 Self::I7(this) => this.max_by_key(f),
5512 Self::I8(this) => this.max_by_key(f),
5513 Self::I9(this) => this.max_by_key(f),
5514 }
5515 }
5516 fn max_by<F>(self, compare: F) -> Option<Self::Item>
5517 where
5518 Self: Sized,
5519 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
5520 {
5521 match self {
5522 Self::I0(this) => this.max_by(compare),
5523 Self::I1(this) => this.max_by(compare),
5524 Self::I2(this) => this.max_by(compare),
5525 Self::I3(this) => this.max_by(compare),
5526 Self::I4(this) => this.max_by(compare),
5527 Self::I5(this) => this.max_by(compare),
5528 Self::I6(this) => this.max_by(compare),
5529 Self::I7(this) => this.max_by(compare),
5530 Self::I8(this) => this.max_by(compare),
5531 Self::I9(this) => this.max_by(compare),
5532 }
5533 }
5534 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
5535 where
5536 Self: Sized,
5537 F: FnMut(&Self::Item) -> B,
5538 {
5539 match self {
5540 Self::I0(this) => this.min_by_key(f),
5541 Self::I1(this) => this.min_by_key(f),
5542 Self::I2(this) => this.min_by_key(f),
5543 Self::I3(this) => this.min_by_key(f),
5544 Self::I4(this) => this.min_by_key(f),
5545 Self::I5(this) => this.min_by_key(f),
5546 Self::I6(this) => this.min_by_key(f),
5547 Self::I7(this) => this.min_by_key(f),
5548 Self::I8(this) => this.min_by_key(f),
5549 Self::I9(this) => this.min_by_key(f),
5550 }
5551 }
5552 fn min_by<F>(self, compare: F) -> Option<Self::Item>
5553 where
5554 Self: Sized,
5555 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
5556 {
5557 match self {
5558 Self::I0(this) => this.min_by(compare),
5559 Self::I1(this) => this.min_by(compare),
5560 Self::I2(this) => this.min_by(compare),
5561 Self::I3(this) => this.min_by(compare),
5562 Self::I4(this) => this.min_by(compare),
5563 Self::I5(this) => this.min_by(compare),
5564 Self::I6(this) => this.min_by(compare),
5565 Self::I7(this) => this.min_by(compare),
5566 Self::I8(this) => this.min_by(compare),
5567 Self::I9(this) => this.min_by(compare),
5568 }
5569 }
5570 fn sum<S>(self) -> S
5571 where
5572 Self: Sized,
5573 S: Sum<Self::Item>,
5574 {
5575 match self {
5576 Self::I0(this) => this.sum(),
5577 Self::I1(this) => this.sum(),
5578 Self::I2(this) => this.sum(),
5579 Self::I3(this) => this.sum(),
5580 Self::I4(this) => this.sum(),
5581 Self::I5(this) => this.sum(),
5582 Self::I6(this) => this.sum(),
5583 Self::I7(this) => this.sum(),
5584 Self::I8(this) => this.sum(),
5585 Self::I9(this) => this.sum(),
5586 }
5587 }
5588 fn product<P>(self) -> P
5589 where
5590 Self: Sized,
5591 P: Product<Self::Item>,
5592 {
5593 match self {
5594 Self::I0(this) => this.product(),
5595 Self::I1(this) => this.product(),
5596 Self::I2(this) => this.product(),
5597 Self::I3(this) => this.product(),
5598 Self::I4(this) => this.product(),
5599 Self::I5(this) => this.product(),
5600 Self::I6(this) => this.product(),
5601 Self::I7(this) => this.product(),
5602 Self::I8(this) => this.product(),
5603 Self::I9(this) => this.product(),
5604 }
5605 }
5606 fn cmp<I>(self, other: I) -> Ordering
5607 where
5608 I: IntoIterator<Item = Self::Item>,
5609 Self::Item: Ord,
5610 Self: Sized,
5611 {
5612 match self {
5613 Self::I0(this) => this.cmp(other),
5614 Self::I1(this) => this.cmp(other),
5615 Self::I2(this) => this.cmp(other),
5616 Self::I3(this) => this.cmp(other),
5617 Self::I4(this) => this.cmp(other),
5618 Self::I5(this) => this.cmp(other),
5619 Self::I6(this) => this.cmp(other),
5620 Self::I7(this) => this.cmp(other),
5621 Self::I8(this) => this.cmp(other),
5622 Self::I9(this) => this.cmp(other),
5623 }
5624 }
5625 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
5626 where
5627 I: IntoIterator,
5628 Self::Item: PartialOrd<I::Item>,
5629 Self: Sized,
5630 {
5631 match self {
5632 Self::I0(this) => this.partial_cmp(other),
5633 Self::I1(this) => this.partial_cmp(other),
5634 Self::I2(this) => this.partial_cmp(other),
5635 Self::I3(this) => this.partial_cmp(other),
5636 Self::I4(this) => this.partial_cmp(other),
5637 Self::I5(this) => this.partial_cmp(other),
5638 Self::I6(this) => this.partial_cmp(other),
5639 Self::I7(this) => this.partial_cmp(other),
5640 Self::I8(this) => this.partial_cmp(other),
5641 Self::I9(this) => this.partial_cmp(other),
5642 }
5643 }
5644 fn eq<I>(self, other: I) -> bool
5645 where
5646 I: IntoIterator,
5647 Self::Item: PartialEq<I::Item>,
5648 Self: Sized,
5649 {
5650 match self {
5651 Self::I0(this) => this.eq(other),
5652 Self::I1(this) => this.eq(other),
5653 Self::I2(this) => this.eq(other),
5654 Self::I3(this) => this.eq(other),
5655 Self::I4(this) => this.eq(other),
5656 Self::I5(this) => this.eq(other),
5657 Self::I6(this) => this.eq(other),
5658 Self::I7(this) => this.eq(other),
5659 Self::I8(this) => this.eq(other),
5660 Self::I9(this) => this.eq(other),
5661 }
5662 }
5663 fn ne<I>(self, other: I) -> bool
5664 where
5665 I: IntoIterator,
5666 Self::Item: PartialEq<I::Item>,
5667 Self: Sized,
5668 {
5669 match self {
5670 Self::I0(this) => this.ne(other),
5671 Self::I1(this) => this.ne(other),
5672 Self::I2(this) => this.ne(other),
5673 Self::I3(this) => this.ne(other),
5674 Self::I4(this) => this.ne(other),
5675 Self::I5(this) => this.ne(other),
5676 Self::I6(this) => this.ne(other),
5677 Self::I7(this) => this.ne(other),
5678 Self::I8(this) => this.ne(other),
5679 Self::I9(this) => this.ne(other),
5680 }
5681 }
5682 fn lt<I>(self, other: I) -> bool
5683 where
5684 I: IntoIterator,
5685 Self::Item: PartialOrd<I::Item>,
5686 Self: Sized,
5687 {
5688 match self {
5689 Self::I0(this) => this.lt(other),
5690 Self::I1(this) => this.lt(other),
5691 Self::I2(this) => this.lt(other),
5692 Self::I3(this) => this.lt(other),
5693 Self::I4(this) => this.lt(other),
5694 Self::I5(this) => this.lt(other),
5695 Self::I6(this) => this.lt(other),
5696 Self::I7(this) => this.lt(other),
5697 Self::I8(this) => this.lt(other),
5698 Self::I9(this) => this.lt(other),
5699 }
5700 }
5701 fn le<I>(self, other: I) -> bool
5702 where
5703 I: IntoIterator,
5704 Self::Item: PartialOrd<I::Item>,
5705 Self: Sized,
5706 {
5707 match self {
5708 Self::I0(this) => this.le(other),
5709 Self::I1(this) => this.le(other),
5710 Self::I2(this) => this.le(other),
5711 Self::I3(this) => this.le(other),
5712 Self::I4(this) => this.le(other),
5713 Self::I5(this) => this.le(other),
5714 Self::I6(this) => this.le(other),
5715 Self::I7(this) => this.le(other),
5716 Self::I8(this) => this.le(other),
5717 Self::I9(this) => this.le(other),
5718 }
5719 }
5720 fn gt<I>(self, other: I) -> bool
5721 where
5722 I: IntoIterator,
5723 Self::Item: PartialOrd<I::Item>,
5724 Self: Sized,
5725 {
5726 match self {
5727 Self::I0(this) => this.gt(other),
5728 Self::I1(this) => this.gt(other),
5729 Self::I2(this) => this.gt(other),
5730 Self::I3(this) => this.gt(other),
5731 Self::I4(this) => this.gt(other),
5732 Self::I5(this) => this.gt(other),
5733 Self::I6(this) => this.gt(other),
5734 Self::I7(this) => this.gt(other),
5735 Self::I8(this) => this.gt(other),
5736 Self::I9(this) => this.gt(other),
5737 }
5738 }
5739 fn ge<I>(self, other: I) -> bool
5740 where
5741 I: IntoIterator,
5742 Self::Item: PartialOrd<I::Item>,
5743 Self: Sized,
5744 {
5745 match self {
5746 Self::I0(this) => this.ge(other),
5747 Self::I1(this) => this.ge(other),
5748 Self::I2(this) => this.ge(other),
5749 Self::I3(this) => this.ge(other),
5750 Self::I4(this) => this.ge(other),
5751 Self::I5(this) => this.ge(other),
5752 Self::I6(this) => this.ge(other),
5753 Self::I7(this) => this.ge(other),
5754 Self::I8(this) => this.ge(other),
5755 Self::I9(this) => this.ge(other),
5756 }
5757 }
5758 }
5759 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9> DoubleEndedIterator
5760 for Iter10<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9>
5761 where
5762 I0: DoubleEndedIterator<Item = Item>,
5763 I1: DoubleEndedIterator<Item = Item>,
5764 I2: DoubleEndedIterator<Item = Item>,
5765 I3: DoubleEndedIterator<Item = Item>,
5766 I4: DoubleEndedIterator<Item = Item>,
5767 I5: DoubleEndedIterator<Item = Item>,
5768 I6: DoubleEndedIterator<Item = Item>,
5769 I7: DoubleEndedIterator<Item = Item>,
5770 I8: DoubleEndedIterator<Item = Item>,
5771 I9: DoubleEndedIterator<Item = Item>,
5772 {
5773 fn next_back(&mut self) -> Option<Self::Item> {
5774 match self {
5775 Self::I0(this) => this.next_back(),
5776 Self::I1(this) => this.next_back(),
5777 Self::I2(this) => this.next_back(),
5778 Self::I3(this) => this.next_back(),
5779 Self::I4(this) => this.next_back(),
5780 Self::I5(this) => this.next_back(),
5781 Self::I6(this) => this.next_back(),
5782 Self::I7(this) => this.next_back(),
5783 Self::I8(this) => this.next_back(),
5784 Self::I9(this) => this.next_back(),
5785 }
5786 }
5787 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
5788 match self {
5789 Self::I0(this) => this.nth_back(n),
5790 Self::I1(this) => this.nth_back(n),
5791 Self::I2(this) => this.nth_back(n),
5792 Self::I3(this) => this.nth_back(n),
5793 Self::I4(this) => this.nth_back(n),
5794 Self::I5(this) => this.nth_back(n),
5795 Self::I6(this) => this.nth_back(n),
5796 Self::I7(this) => this.nth_back(n),
5797 Self::I8(this) => this.nth_back(n),
5798 Self::I9(this) => this.nth_back(n),
5799 }
5800 }
5801 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
5802 where
5803 P: FnMut(&Self::Item) -> bool,
5804 {
5805 match self {
5806 Self::I0(this) => this.rfind(predicate),
5807 Self::I1(this) => this.rfind(predicate),
5808 Self::I2(this) => this.rfind(predicate),
5809 Self::I3(this) => this.rfind(predicate),
5810 Self::I4(this) => this.rfind(predicate),
5811 Self::I5(this) => this.rfind(predicate),
5812 Self::I6(this) => this.rfind(predicate),
5813 Self::I7(this) => this.rfind(predicate),
5814 Self::I8(this) => this.rfind(predicate),
5815 Self::I9(this) => this.rfind(predicate),
5816 }
5817 }
5818 fn rfold<B, F>(self, init: B, f: F) -> B
5819 where
5820 Self: Sized,
5821 F: FnMut(B, Self::Item) -> B,
5822 {
5823 match self {
5824 Self::I0(this) => this.rfold(init, f),
5825 Self::I1(this) => this.rfold(init, f),
5826 Self::I2(this) => this.rfold(init, f),
5827 Self::I3(this) => this.rfold(init, f),
5828 Self::I4(this) => this.rfold(init, f),
5829 Self::I5(this) => this.rfold(init, f),
5830 Self::I6(this) => this.rfold(init, f),
5831 Self::I7(this) => this.rfold(init, f),
5832 Self::I8(this) => this.rfold(init, f),
5833 Self::I9(this) => this.rfold(init, f),
5834 }
5835 }
5836 }
5837 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9> ExactSizeIterator
5838 for Iter10<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9>
5839 where
5840 I0: ExactSizeIterator<Item = Item>,
5841 I1: ExactSizeIterator<Item = Item>,
5842 I2: ExactSizeIterator<Item = Item>,
5843 I3: ExactSizeIterator<Item = Item>,
5844 I4: ExactSizeIterator<Item = Item>,
5845 I5: ExactSizeIterator<Item = Item>,
5846 I6: ExactSizeIterator<Item = Item>,
5847 I7: ExactSizeIterator<Item = Item>,
5848 I8: ExactSizeIterator<Item = Item>,
5849 I9: ExactSizeIterator<Item = Item>,
5850 {
5851 fn len(&self) -> usize {
5852 match self {
5853 Self::I0(this) => this.len(),
5854 Self::I1(this) => this.len(),
5855 Self::I2(this) => this.len(),
5856 Self::I3(this) => this.len(),
5857 Self::I4(this) => this.len(),
5858 Self::I5(this) => this.len(),
5859 Self::I6(this) => this.len(),
5860 Self::I7(this) => this.len(),
5861 Self::I8(this) => this.len(),
5862 Self::I9(this) => this.len(),
5863 }
5864 }
5865 }
5866 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9> FusedIterator
5867 for Iter10<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9>
5868 where
5869 I0: FusedIterator<Item = Item>,
5870 I1: FusedIterator<Item = Item>,
5871 I2: FusedIterator<Item = Item>,
5872 I3: FusedIterator<Item = Item>,
5873 I4: FusedIterator<Item = Item>,
5874 I5: FusedIterator<Item = Item>,
5875 I6: FusedIterator<Item = Item>,
5876 I7: FusedIterator<Item = Item>,
5877 I8: FusedIterator<Item = Item>,
5878 I9: FusedIterator<Item = Item>,
5879 {
5880 }
5881}
5882pub mod iter11 {
5883 use super::*;
5884 use core::iter::FusedIterator;
5885 #[derive(Debug, Clone, Copy)]
5886 pub enum Iter11<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> {
5887 I0(I0),
5888 I1(I1),
5889 I2(I2),
5890 I3(I3),
5891 I4(I4),
5892 I5(I5),
5893 I6(I6),
5894 I7(I7),
5895 I8(I8),
5896 I9(I9),
5897 I10(I10),
5898 }
5899 pub trait IntoIter0: IntoIterator {
5900 #[allow(clippy::type_complexity)]
5901 fn into_iter0<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>(
5902 self,
5903 ) -> Iter11<Self::IntoIter, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>;
5904 }
5905 impl<T: IntoIterator> IntoIter0 for T {
5906 #[allow(clippy::type_complexity)]
5907 fn into_iter0<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>(
5908 self,
5909 ) -> Iter11<Self::IntoIter, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> {
5910 Iter11::I0(self.into_iter())
5911 }
5912 }
5913 pub trait IntoIter1: IntoIterator {
5914 #[allow(clippy::type_complexity)]
5915 fn into_iter1<I0, I2, I3, I4, I5, I6, I7, I8, I9, I10>(
5916 self,
5917 ) -> Iter11<I0, Self::IntoIter, I2, I3, I4, I5, I6, I7, I8, I9, I10>;
5918 }
5919 impl<T: IntoIterator> IntoIter1 for T {
5920 #[allow(clippy::type_complexity)]
5921 fn into_iter1<I0, I2, I3, I4, I5, I6, I7, I8, I9, I10>(
5922 self,
5923 ) -> Iter11<I0, Self::IntoIter, I2, I3, I4, I5, I6, I7, I8, I9, I10> {
5924 Iter11::I1(self.into_iter())
5925 }
5926 }
5927 pub trait IntoIter2: IntoIterator {
5928 #[allow(clippy::type_complexity)]
5929 fn into_iter2<I0, I1, I3, I4, I5, I6, I7, I8, I9, I10>(
5930 self,
5931 ) -> Iter11<I0, I1, Self::IntoIter, I3, I4, I5, I6, I7, I8, I9, I10>;
5932 }
5933 impl<T: IntoIterator> IntoIter2 for T {
5934 #[allow(clippy::type_complexity)]
5935 fn into_iter2<I0, I1, I3, I4, I5, I6, I7, I8, I9, I10>(
5936 self,
5937 ) -> Iter11<I0, I1, Self::IntoIter, I3, I4, I5, I6, I7, I8, I9, I10> {
5938 Iter11::I2(self.into_iter())
5939 }
5940 }
5941 pub trait IntoIter3: IntoIterator {
5942 #[allow(clippy::type_complexity)]
5943 fn into_iter3<I0, I1, I2, I4, I5, I6, I7, I8, I9, I10>(
5944 self,
5945 ) -> Iter11<I0, I1, I2, Self::IntoIter, I4, I5, I6, I7, I8, I9, I10>;
5946 }
5947 impl<T: IntoIterator> IntoIter3 for T {
5948 #[allow(clippy::type_complexity)]
5949 fn into_iter3<I0, I1, I2, I4, I5, I6, I7, I8, I9, I10>(
5950 self,
5951 ) -> Iter11<I0, I1, I2, Self::IntoIter, I4, I5, I6, I7, I8, I9, I10> {
5952 Iter11::I3(self.into_iter())
5953 }
5954 }
5955 pub trait IntoIter4: IntoIterator {
5956 #[allow(clippy::type_complexity)]
5957 fn into_iter4<I0, I1, I2, I3, I5, I6, I7, I8, I9, I10>(
5958 self,
5959 ) -> Iter11<I0, I1, I2, I3, Self::IntoIter, I5, I6, I7, I8, I9, I10>;
5960 }
5961 impl<T: IntoIterator> IntoIter4 for T {
5962 #[allow(clippy::type_complexity)]
5963 fn into_iter4<I0, I1, I2, I3, I5, I6, I7, I8, I9, I10>(
5964 self,
5965 ) -> Iter11<I0, I1, I2, I3, Self::IntoIter, I5, I6, I7, I8, I9, I10> {
5966 Iter11::I4(self.into_iter())
5967 }
5968 }
5969 pub trait IntoIter5: IntoIterator {
5970 #[allow(clippy::type_complexity)]
5971 fn into_iter5<I0, I1, I2, I3, I4, I6, I7, I8, I9, I10>(
5972 self,
5973 ) -> Iter11<I0, I1, I2, I3, I4, Self::IntoIter, I6, I7, I8, I9, I10>;
5974 }
5975 impl<T: IntoIterator> IntoIter5 for T {
5976 #[allow(clippy::type_complexity)]
5977 fn into_iter5<I0, I1, I2, I3, I4, I6, I7, I8, I9, I10>(
5978 self,
5979 ) -> Iter11<I0, I1, I2, I3, I4, Self::IntoIter, I6, I7, I8, I9, I10> {
5980 Iter11::I5(self.into_iter())
5981 }
5982 }
5983 pub trait IntoIter6: IntoIterator {
5984 #[allow(clippy::type_complexity)]
5985 fn into_iter6<I0, I1, I2, I3, I4, I5, I7, I8, I9, I10>(
5986 self,
5987 ) -> Iter11<I0, I1, I2, I3, I4, I5, Self::IntoIter, I7, I8, I9, I10>;
5988 }
5989 impl<T: IntoIterator> IntoIter6 for T {
5990 #[allow(clippy::type_complexity)]
5991 fn into_iter6<I0, I1, I2, I3, I4, I5, I7, I8, I9, I10>(
5992 self,
5993 ) -> Iter11<I0, I1, I2, I3, I4, I5, Self::IntoIter, I7, I8, I9, I10> {
5994 Iter11::I6(self.into_iter())
5995 }
5996 }
5997 pub trait IntoIter7: IntoIterator {
5998 #[allow(clippy::type_complexity)]
5999 fn into_iter7<I0, I1, I2, I3, I4, I5, I6, I8, I9, I10>(
6000 self,
6001 ) -> Iter11<I0, I1, I2, I3, I4, I5, I6, Self::IntoIter, I8, I9, I10>;
6002 }
6003 impl<T: IntoIterator> IntoIter7 for T {
6004 #[allow(clippy::type_complexity)]
6005 fn into_iter7<I0, I1, I2, I3, I4, I5, I6, I8, I9, I10>(
6006 self,
6007 ) -> Iter11<I0, I1, I2, I3, I4, I5, I6, Self::IntoIter, I8, I9, I10> {
6008 Iter11::I7(self.into_iter())
6009 }
6010 }
6011 pub trait IntoIter8: IntoIterator {
6012 #[allow(clippy::type_complexity)]
6013 fn into_iter8<I0, I1, I2, I3, I4, I5, I6, I7, I9, I10>(
6014 self,
6015 ) -> Iter11<I0, I1, I2, I3, I4, I5, I6, I7, Self::IntoIter, I9, I10>;
6016 }
6017 impl<T: IntoIterator> IntoIter8 for T {
6018 #[allow(clippy::type_complexity)]
6019 fn into_iter8<I0, I1, I2, I3, I4, I5, I6, I7, I9, I10>(
6020 self,
6021 ) -> Iter11<I0, I1, I2, I3, I4, I5, I6, I7, Self::IntoIter, I9, I10> {
6022 Iter11::I8(self.into_iter())
6023 }
6024 }
6025 pub trait IntoIter9: IntoIterator {
6026 #[allow(clippy::type_complexity)]
6027 fn into_iter9<I0, I1, I2, I3, I4, I5, I6, I7, I8, I10>(
6028 self,
6029 ) -> Iter11<I0, I1, I2, I3, I4, I5, I6, I7, I8, Self::IntoIter, I10>;
6030 }
6031 impl<T: IntoIterator> IntoIter9 for T {
6032 #[allow(clippy::type_complexity)]
6033 fn into_iter9<I0, I1, I2, I3, I4, I5, I6, I7, I8, I10>(
6034 self,
6035 ) -> Iter11<I0, I1, I2, I3, I4, I5, I6, I7, I8, Self::IntoIter, I10> {
6036 Iter11::I9(self.into_iter())
6037 }
6038 }
6039 pub trait IntoIter10: IntoIterator {
6040 #[allow(clippy::type_complexity)]
6041 fn into_iter10<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9>(
6042 self,
6043 ) -> Iter11<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, Self::IntoIter>;
6044 }
6045 impl<T: IntoIterator> IntoIter10 for T {
6046 #[allow(clippy::type_complexity)]
6047 fn into_iter10<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9>(
6048 self,
6049 ) -> Iter11<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, Self::IntoIter> {
6050 Iter11::I10(self.into_iter())
6051 }
6052 }
6053 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> Iterator
6054 for Iter11<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
6055 where
6056 I0: Iterator<Item = Item>,
6057 I1: Iterator<Item = Item>,
6058 I2: Iterator<Item = Item>,
6059 I3: Iterator<Item = Item>,
6060 I4: Iterator<Item = Item>,
6061 I5: Iterator<Item = Item>,
6062 I6: Iterator<Item = Item>,
6063 I7: Iterator<Item = Item>,
6064 I8: Iterator<Item = Item>,
6065 I9: Iterator<Item = Item>,
6066 I10: Iterator<Item = Item>,
6067 {
6068 type Item = Item;
6069 fn next(&mut self) -> Option<Self::Item> {
6070 match self {
6071 Self::I0(this) => this.next(),
6072 Self::I1(this) => this.next(),
6073 Self::I2(this) => this.next(),
6074 Self::I3(this) => this.next(),
6075 Self::I4(this) => this.next(),
6076 Self::I5(this) => this.next(),
6077 Self::I6(this) => this.next(),
6078 Self::I7(this) => this.next(),
6079 Self::I8(this) => this.next(),
6080 Self::I9(this) => this.next(),
6081 Self::I10(this) => this.next(),
6082 }
6083 }
6084 fn size_hint(&self) -> (usize, Option<usize>) {
6085 match self {
6086 Self::I0(this) => this.size_hint(),
6087 Self::I1(this) => this.size_hint(),
6088 Self::I2(this) => this.size_hint(),
6089 Self::I3(this) => this.size_hint(),
6090 Self::I4(this) => this.size_hint(),
6091 Self::I5(this) => this.size_hint(),
6092 Self::I6(this) => this.size_hint(),
6093 Self::I7(this) => this.size_hint(),
6094 Self::I8(this) => this.size_hint(),
6095 Self::I9(this) => this.size_hint(),
6096 Self::I10(this) => this.size_hint(),
6097 }
6098 }
6099 fn count(self) -> usize
6100 where
6101 Self: Sized,
6102 {
6103 match self {
6104 Self::I0(this) => this.count(),
6105 Self::I1(this) => this.count(),
6106 Self::I2(this) => this.count(),
6107 Self::I3(this) => this.count(),
6108 Self::I4(this) => this.count(),
6109 Self::I5(this) => this.count(),
6110 Self::I6(this) => this.count(),
6111 Self::I7(this) => this.count(),
6112 Self::I8(this) => this.count(),
6113 Self::I9(this) => this.count(),
6114 Self::I10(this) => this.count(),
6115 }
6116 }
6117 fn last(self) -> Option<Self::Item>
6118 where
6119 Self: Sized,
6120 {
6121 match self {
6122 Self::I0(this) => this.last(),
6123 Self::I1(this) => this.last(),
6124 Self::I2(this) => this.last(),
6125 Self::I3(this) => this.last(),
6126 Self::I4(this) => this.last(),
6127 Self::I5(this) => this.last(),
6128 Self::I6(this) => this.last(),
6129 Self::I7(this) => this.last(),
6130 Self::I8(this) => this.last(),
6131 Self::I9(this) => this.last(),
6132 Self::I10(this) => this.last(),
6133 }
6134 }
6135 fn nth(&mut self, n: usize) -> Option<Self::Item> {
6136 match self {
6137 Self::I0(this) => this.nth(n),
6138 Self::I1(this) => this.nth(n),
6139 Self::I2(this) => this.nth(n),
6140 Self::I3(this) => this.nth(n),
6141 Self::I4(this) => this.nth(n),
6142 Self::I5(this) => this.nth(n),
6143 Self::I6(this) => this.nth(n),
6144 Self::I7(this) => this.nth(n),
6145 Self::I8(this) => this.nth(n),
6146 Self::I9(this) => this.nth(n),
6147 Self::I10(this) => this.nth(n),
6148 }
6149 }
6150 fn for_each<F>(self, f: F)
6151 where
6152 Self: Sized,
6153 F: FnMut(Self::Item),
6154 {
6155 match self {
6156 Self::I0(this) => this.for_each(f),
6157 Self::I1(this) => this.for_each(f),
6158 Self::I2(this) => this.for_each(f),
6159 Self::I3(this) => this.for_each(f),
6160 Self::I4(this) => this.for_each(f),
6161 Self::I5(this) => this.for_each(f),
6162 Self::I6(this) => this.for_each(f),
6163 Self::I7(this) => this.for_each(f),
6164 Self::I8(this) => this.for_each(f),
6165 Self::I9(this) => this.for_each(f),
6166 Self::I10(this) => this.for_each(f),
6167 }
6168 }
6169 fn collect<B: FromIterator<Self::Item>>(self) -> B
6170 where
6171 Self: Sized,
6172 {
6173 match self {
6174 Self::I0(this) => this.collect(),
6175 Self::I1(this) => this.collect(),
6176 Self::I2(this) => this.collect(),
6177 Self::I3(this) => this.collect(),
6178 Self::I4(this) => this.collect(),
6179 Self::I5(this) => this.collect(),
6180 Self::I6(this) => this.collect(),
6181 Self::I7(this) => this.collect(),
6182 Self::I8(this) => this.collect(),
6183 Self::I9(this) => this.collect(),
6184 Self::I10(this) => this.collect(),
6185 }
6186 }
6187 fn partition<B, F>(self, f: F) -> (B, B)
6188 where
6189 Self: Sized,
6190 B: Default + Extend<Self::Item>,
6191 F: FnMut(&Self::Item) -> bool,
6192 {
6193 match self {
6194 Self::I0(this) => this.partition(f),
6195 Self::I1(this) => this.partition(f),
6196 Self::I2(this) => this.partition(f),
6197 Self::I3(this) => this.partition(f),
6198 Self::I4(this) => this.partition(f),
6199 Self::I5(this) => this.partition(f),
6200 Self::I6(this) => this.partition(f),
6201 Self::I7(this) => this.partition(f),
6202 Self::I8(this) => this.partition(f),
6203 Self::I9(this) => this.partition(f),
6204 Self::I10(this) => this.partition(f),
6205 }
6206 }
6207 fn fold<B, F>(self, init: B, f: F) -> B
6208 where
6209 Self: Sized,
6210 F: FnMut(B, Self::Item) -> B,
6211 {
6212 match self {
6213 Self::I0(this) => this.fold(init, f),
6214 Self::I1(this) => this.fold(init, f),
6215 Self::I2(this) => this.fold(init, f),
6216 Self::I3(this) => this.fold(init, f),
6217 Self::I4(this) => this.fold(init, f),
6218 Self::I5(this) => this.fold(init, f),
6219 Self::I6(this) => this.fold(init, f),
6220 Self::I7(this) => this.fold(init, f),
6221 Self::I8(this) => this.fold(init, f),
6222 Self::I9(this) => this.fold(init, f),
6223 Self::I10(this) => this.fold(init, f),
6224 }
6225 }
6226 fn reduce<F>(self, f: F) -> Option<Self::Item>
6227 where
6228 Self: Sized,
6229 F: FnMut(Self::Item, Self::Item) -> Self::Item,
6230 {
6231 match self {
6232 Self::I0(this) => this.reduce(f),
6233 Self::I1(this) => this.reduce(f),
6234 Self::I2(this) => this.reduce(f),
6235 Self::I3(this) => this.reduce(f),
6236 Self::I4(this) => this.reduce(f),
6237 Self::I5(this) => this.reduce(f),
6238 Self::I6(this) => this.reduce(f),
6239 Self::I7(this) => this.reduce(f),
6240 Self::I8(this) => this.reduce(f),
6241 Self::I9(this) => this.reduce(f),
6242 Self::I10(this) => this.reduce(f),
6243 }
6244 }
6245 fn all<F>(&mut self, f: F) -> bool
6246 where
6247 Self: Sized,
6248 F: FnMut(Self::Item) -> bool,
6249 {
6250 match self {
6251 Self::I0(this) => this.all(f),
6252 Self::I1(this) => this.all(f),
6253 Self::I2(this) => this.all(f),
6254 Self::I3(this) => this.all(f),
6255 Self::I4(this) => this.all(f),
6256 Self::I5(this) => this.all(f),
6257 Self::I6(this) => this.all(f),
6258 Self::I7(this) => this.all(f),
6259 Self::I8(this) => this.all(f),
6260 Self::I9(this) => this.all(f),
6261 Self::I10(this) => this.all(f),
6262 }
6263 }
6264 fn any<F>(&mut self, f: F) -> bool
6265 where
6266 Self: Sized,
6267 F: FnMut(Self::Item) -> bool,
6268 {
6269 match self {
6270 Self::I0(this) => this.any(f),
6271 Self::I1(this) => this.any(f),
6272 Self::I2(this) => this.any(f),
6273 Self::I3(this) => this.any(f),
6274 Self::I4(this) => this.any(f),
6275 Self::I5(this) => this.any(f),
6276 Self::I6(this) => this.any(f),
6277 Self::I7(this) => this.any(f),
6278 Self::I8(this) => this.any(f),
6279 Self::I9(this) => this.any(f),
6280 Self::I10(this) => this.any(f),
6281 }
6282 }
6283 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
6284 where
6285 Self: Sized,
6286 P: FnMut(&Self::Item) -> bool,
6287 {
6288 match self {
6289 Self::I0(this) => this.find(predicate),
6290 Self::I1(this) => this.find(predicate),
6291 Self::I2(this) => this.find(predicate),
6292 Self::I3(this) => this.find(predicate),
6293 Self::I4(this) => this.find(predicate),
6294 Self::I5(this) => this.find(predicate),
6295 Self::I6(this) => this.find(predicate),
6296 Self::I7(this) => this.find(predicate),
6297 Self::I8(this) => this.find(predicate),
6298 Self::I9(this) => this.find(predicate),
6299 Self::I10(this) => this.find(predicate),
6300 }
6301 }
6302 fn find_map<B, F>(&mut self, f: F) -> Option<B>
6303 where
6304 Self: Sized,
6305 F: FnMut(Self::Item) -> Option<B>,
6306 {
6307 match self {
6308 Self::I0(this) => this.find_map(f),
6309 Self::I1(this) => this.find_map(f),
6310 Self::I2(this) => this.find_map(f),
6311 Self::I3(this) => this.find_map(f),
6312 Self::I4(this) => this.find_map(f),
6313 Self::I5(this) => this.find_map(f),
6314 Self::I6(this) => this.find_map(f),
6315 Self::I7(this) => this.find_map(f),
6316 Self::I8(this) => this.find_map(f),
6317 Self::I9(this) => this.find_map(f),
6318 Self::I10(this) => this.find_map(f),
6319 }
6320 }
6321 fn position<P>(&mut self, predicate: P) -> Option<usize>
6322 where
6323 Self: Sized,
6324 P: FnMut(Self::Item) -> bool,
6325 {
6326 match self {
6327 Self::I0(this) => this.position(predicate),
6328 Self::I1(this) => this.position(predicate),
6329 Self::I2(this) => this.position(predicate),
6330 Self::I3(this) => this.position(predicate),
6331 Self::I4(this) => this.position(predicate),
6332 Self::I5(this) => this.position(predicate),
6333 Self::I6(this) => this.position(predicate),
6334 Self::I7(this) => this.position(predicate),
6335 Self::I8(this) => this.position(predicate),
6336 Self::I9(this) => this.position(predicate),
6337 Self::I10(this) => this.position(predicate),
6338 }
6339 }
6340 fn max(self) -> Option<Self::Item>
6341 where
6342 Self: Sized,
6343 Self::Item: Ord,
6344 {
6345 match self {
6346 Self::I0(this) => this.max(),
6347 Self::I1(this) => this.max(),
6348 Self::I2(this) => this.max(),
6349 Self::I3(this) => this.max(),
6350 Self::I4(this) => this.max(),
6351 Self::I5(this) => this.max(),
6352 Self::I6(this) => this.max(),
6353 Self::I7(this) => this.max(),
6354 Self::I8(this) => this.max(),
6355 Self::I9(this) => this.max(),
6356 Self::I10(this) => this.max(),
6357 }
6358 }
6359 fn min(self) -> Option<Self::Item>
6360 where
6361 Self: Sized,
6362 Self::Item: Ord,
6363 {
6364 match self {
6365 Self::I0(this) => this.min(),
6366 Self::I1(this) => this.min(),
6367 Self::I2(this) => this.min(),
6368 Self::I3(this) => this.min(),
6369 Self::I4(this) => this.min(),
6370 Self::I5(this) => this.min(),
6371 Self::I6(this) => this.min(),
6372 Self::I7(this) => this.min(),
6373 Self::I8(this) => this.min(),
6374 Self::I9(this) => this.min(),
6375 Self::I10(this) => this.min(),
6376 }
6377 }
6378 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
6379 where
6380 Self: Sized,
6381 F: FnMut(&Self::Item) -> B,
6382 {
6383 match self {
6384 Self::I0(this) => this.max_by_key(f),
6385 Self::I1(this) => this.max_by_key(f),
6386 Self::I2(this) => this.max_by_key(f),
6387 Self::I3(this) => this.max_by_key(f),
6388 Self::I4(this) => this.max_by_key(f),
6389 Self::I5(this) => this.max_by_key(f),
6390 Self::I6(this) => this.max_by_key(f),
6391 Self::I7(this) => this.max_by_key(f),
6392 Self::I8(this) => this.max_by_key(f),
6393 Self::I9(this) => this.max_by_key(f),
6394 Self::I10(this) => this.max_by_key(f),
6395 }
6396 }
6397 fn max_by<F>(self, compare: F) -> Option<Self::Item>
6398 where
6399 Self: Sized,
6400 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
6401 {
6402 match self {
6403 Self::I0(this) => this.max_by(compare),
6404 Self::I1(this) => this.max_by(compare),
6405 Self::I2(this) => this.max_by(compare),
6406 Self::I3(this) => this.max_by(compare),
6407 Self::I4(this) => this.max_by(compare),
6408 Self::I5(this) => this.max_by(compare),
6409 Self::I6(this) => this.max_by(compare),
6410 Self::I7(this) => this.max_by(compare),
6411 Self::I8(this) => this.max_by(compare),
6412 Self::I9(this) => this.max_by(compare),
6413 Self::I10(this) => this.max_by(compare),
6414 }
6415 }
6416 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
6417 where
6418 Self: Sized,
6419 F: FnMut(&Self::Item) -> B,
6420 {
6421 match self {
6422 Self::I0(this) => this.min_by_key(f),
6423 Self::I1(this) => this.min_by_key(f),
6424 Self::I2(this) => this.min_by_key(f),
6425 Self::I3(this) => this.min_by_key(f),
6426 Self::I4(this) => this.min_by_key(f),
6427 Self::I5(this) => this.min_by_key(f),
6428 Self::I6(this) => this.min_by_key(f),
6429 Self::I7(this) => this.min_by_key(f),
6430 Self::I8(this) => this.min_by_key(f),
6431 Self::I9(this) => this.min_by_key(f),
6432 Self::I10(this) => this.min_by_key(f),
6433 }
6434 }
6435 fn min_by<F>(self, compare: F) -> Option<Self::Item>
6436 where
6437 Self: Sized,
6438 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
6439 {
6440 match self {
6441 Self::I0(this) => this.min_by(compare),
6442 Self::I1(this) => this.min_by(compare),
6443 Self::I2(this) => this.min_by(compare),
6444 Self::I3(this) => this.min_by(compare),
6445 Self::I4(this) => this.min_by(compare),
6446 Self::I5(this) => this.min_by(compare),
6447 Self::I6(this) => this.min_by(compare),
6448 Self::I7(this) => this.min_by(compare),
6449 Self::I8(this) => this.min_by(compare),
6450 Self::I9(this) => this.min_by(compare),
6451 Self::I10(this) => this.min_by(compare),
6452 }
6453 }
6454 fn sum<S>(self) -> S
6455 where
6456 Self: Sized,
6457 S: Sum<Self::Item>,
6458 {
6459 match self {
6460 Self::I0(this) => this.sum(),
6461 Self::I1(this) => this.sum(),
6462 Self::I2(this) => this.sum(),
6463 Self::I3(this) => this.sum(),
6464 Self::I4(this) => this.sum(),
6465 Self::I5(this) => this.sum(),
6466 Self::I6(this) => this.sum(),
6467 Self::I7(this) => this.sum(),
6468 Self::I8(this) => this.sum(),
6469 Self::I9(this) => this.sum(),
6470 Self::I10(this) => this.sum(),
6471 }
6472 }
6473 fn product<P>(self) -> P
6474 where
6475 Self: Sized,
6476 P: Product<Self::Item>,
6477 {
6478 match self {
6479 Self::I0(this) => this.product(),
6480 Self::I1(this) => this.product(),
6481 Self::I2(this) => this.product(),
6482 Self::I3(this) => this.product(),
6483 Self::I4(this) => this.product(),
6484 Self::I5(this) => this.product(),
6485 Self::I6(this) => this.product(),
6486 Self::I7(this) => this.product(),
6487 Self::I8(this) => this.product(),
6488 Self::I9(this) => this.product(),
6489 Self::I10(this) => this.product(),
6490 }
6491 }
6492 fn cmp<I>(self, other: I) -> Ordering
6493 where
6494 I: IntoIterator<Item = Self::Item>,
6495 Self::Item: Ord,
6496 Self: Sized,
6497 {
6498 match self {
6499 Self::I0(this) => this.cmp(other),
6500 Self::I1(this) => this.cmp(other),
6501 Self::I2(this) => this.cmp(other),
6502 Self::I3(this) => this.cmp(other),
6503 Self::I4(this) => this.cmp(other),
6504 Self::I5(this) => this.cmp(other),
6505 Self::I6(this) => this.cmp(other),
6506 Self::I7(this) => this.cmp(other),
6507 Self::I8(this) => this.cmp(other),
6508 Self::I9(this) => this.cmp(other),
6509 Self::I10(this) => this.cmp(other),
6510 }
6511 }
6512 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
6513 where
6514 I: IntoIterator,
6515 Self::Item: PartialOrd<I::Item>,
6516 Self: Sized,
6517 {
6518 match self {
6519 Self::I0(this) => this.partial_cmp(other),
6520 Self::I1(this) => this.partial_cmp(other),
6521 Self::I2(this) => this.partial_cmp(other),
6522 Self::I3(this) => this.partial_cmp(other),
6523 Self::I4(this) => this.partial_cmp(other),
6524 Self::I5(this) => this.partial_cmp(other),
6525 Self::I6(this) => this.partial_cmp(other),
6526 Self::I7(this) => this.partial_cmp(other),
6527 Self::I8(this) => this.partial_cmp(other),
6528 Self::I9(this) => this.partial_cmp(other),
6529 Self::I10(this) => this.partial_cmp(other),
6530 }
6531 }
6532 fn eq<I>(self, other: I) -> bool
6533 where
6534 I: IntoIterator,
6535 Self::Item: PartialEq<I::Item>,
6536 Self: Sized,
6537 {
6538 match self {
6539 Self::I0(this) => this.eq(other),
6540 Self::I1(this) => this.eq(other),
6541 Self::I2(this) => this.eq(other),
6542 Self::I3(this) => this.eq(other),
6543 Self::I4(this) => this.eq(other),
6544 Self::I5(this) => this.eq(other),
6545 Self::I6(this) => this.eq(other),
6546 Self::I7(this) => this.eq(other),
6547 Self::I8(this) => this.eq(other),
6548 Self::I9(this) => this.eq(other),
6549 Self::I10(this) => this.eq(other),
6550 }
6551 }
6552 fn ne<I>(self, other: I) -> bool
6553 where
6554 I: IntoIterator,
6555 Self::Item: PartialEq<I::Item>,
6556 Self: Sized,
6557 {
6558 match self {
6559 Self::I0(this) => this.ne(other),
6560 Self::I1(this) => this.ne(other),
6561 Self::I2(this) => this.ne(other),
6562 Self::I3(this) => this.ne(other),
6563 Self::I4(this) => this.ne(other),
6564 Self::I5(this) => this.ne(other),
6565 Self::I6(this) => this.ne(other),
6566 Self::I7(this) => this.ne(other),
6567 Self::I8(this) => this.ne(other),
6568 Self::I9(this) => this.ne(other),
6569 Self::I10(this) => this.ne(other),
6570 }
6571 }
6572 fn lt<I>(self, other: I) -> bool
6573 where
6574 I: IntoIterator,
6575 Self::Item: PartialOrd<I::Item>,
6576 Self: Sized,
6577 {
6578 match self {
6579 Self::I0(this) => this.lt(other),
6580 Self::I1(this) => this.lt(other),
6581 Self::I2(this) => this.lt(other),
6582 Self::I3(this) => this.lt(other),
6583 Self::I4(this) => this.lt(other),
6584 Self::I5(this) => this.lt(other),
6585 Self::I6(this) => this.lt(other),
6586 Self::I7(this) => this.lt(other),
6587 Self::I8(this) => this.lt(other),
6588 Self::I9(this) => this.lt(other),
6589 Self::I10(this) => this.lt(other),
6590 }
6591 }
6592 fn le<I>(self, other: I) -> bool
6593 where
6594 I: IntoIterator,
6595 Self::Item: PartialOrd<I::Item>,
6596 Self: Sized,
6597 {
6598 match self {
6599 Self::I0(this) => this.le(other),
6600 Self::I1(this) => this.le(other),
6601 Self::I2(this) => this.le(other),
6602 Self::I3(this) => this.le(other),
6603 Self::I4(this) => this.le(other),
6604 Self::I5(this) => this.le(other),
6605 Self::I6(this) => this.le(other),
6606 Self::I7(this) => this.le(other),
6607 Self::I8(this) => this.le(other),
6608 Self::I9(this) => this.le(other),
6609 Self::I10(this) => this.le(other),
6610 }
6611 }
6612 fn gt<I>(self, other: I) -> bool
6613 where
6614 I: IntoIterator,
6615 Self::Item: PartialOrd<I::Item>,
6616 Self: Sized,
6617 {
6618 match self {
6619 Self::I0(this) => this.gt(other),
6620 Self::I1(this) => this.gt(other),
6621 Self::I2(this) => this.gt(other),
6622 Self::I3(this) => this.gt(other),
6623 Self::I4(this) => this.gt(other),
6624 Self::I5(this) => this.gt(other),
6625 Self::I6(this) => this.gt(other),
6626 Self::I7(this) => this.gt(other),
6627 Self::I8(this) => this.gt(other),
6628 Self::I9(this) => this.gt(other),
6629 Self::I10(this) => this.gt(other),
6630 }
6631 }
6632 fn ge<I>(self, other: I) -> bool
6633 where
6634 I: IntoIterator,
6635 Self::Item: PartialOrd<I::Item>,
6636 Self: Sized,
6637 {
6638 match self {
6639 Self::I0(this) => this.ge(other),
6640 Self::I1(this) => this.ge(other),
6641 Self::I2(this) => this.ge(other),
6642 Self::I3(this) => this.ge(other),
6643 Self::I4(this) => this.ge(other),
6644 Self::I5(this) => this.ge(other),
6645 Self::I6(this) => this.ge(other),
6646 Self::I7(this) => this.ge(other),
6647 Self::I8(this) => this.ge(other),
6648 Self::I9(this) => this.ge(other),
6649 Self::I10(this) => this.ge(other),
6650 }
6651 }
6652 }
6653 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> DoubleEndedIterator
6654 for Iter11<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
6655 where
6656 I0: DoubleEndedIterator<Item = Item>,
6657 I1: DoubleEndedIterator<Item = Item>,
6658 I2: DoubleEndedIterator<Item = Item>,
6659 I3: DoubleEndedIterator<Item = Item>,
6660 I4: DoubleEndedIterator<Item = Item>,
6661 I5: DoubleEndedIterator<Item = Item>,
6662 I6: DoubleEndedIterator<Item = Item>,
6663 I7: DoubleEndedIterator<Item = Item>,
6664 I8: DoubleEndedIterator<Item = Item>,
6665 I9: DoubleEndedIterator<Item = Item>,
6666 I10: DoubleEndedIterator<Item = Item>,
6667 {
6668 fn next_back(&mut self) -> Option<Self::Item> {
6669 match self {
6670 Self::I0(this) => this.next_back(),
6671 Self::I1(this) => this.next_back(),
6672 Self::I2(this) => this.next_back(),
6673 Self::I3(this) => this.next_back(),
6674 Self::I4(this) => this.next_back(),
6675 Self::I5(this) => this.next_back(),
6676 Self::I6(this) => this.next_back(),
6677 Self::I7(this) => this.next_back(),
6678 Self::I8(this) => this.next_back(),
6679 Self::I9(this) => this.next_back(),
6680 Self::I10(this) => this.next_back(),
6681 }
6682 }
6683 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
6684 match self {
6685 Self::I0(this) => this.nth_back(n),
6686 Self::I1(this) => this.nth_back(n),
6687 Self::I2(this) => this.nth_back(n),
6688 Self::I3(this) => this.nth_back(n),
6689 Self::I4(this) => this.nth_back(n),
6690 Self::I5(this) => this.nth_back(n),
6691 Self::I6(this) => this.nth_back(n),
6692 Self::I7(this) => this.nth_back(n),
6693 Self::I8(this) => this.nth_back(n),
6694 Self::I9(this) => this.nth_back(n),
6695 Self::I10(this) => this.nth_back(n),
6696 }
6697 }
6698 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
6699 where
6700 P: FnMut(&Self::Item) -> bool,
6701 {
6702 match self {
6703 Self::I0(this) => this.rfind(predicate),
6704 Self::I1(this) => this.rfind(predicate),
6705 Self::I2(this) => this.rfind(predicate),
6706 Self::I3(this) => this.rfind(predicate),
6707 Self::I4(this) => this.rfind(predicate),
6708 Self::I5(this) => this.rfind(predicate),
6709 Self::I6(this) => this.rfind(predicate),
6710 Self::I7(this) => this.rfind(predicate),
6711 Self::I8(this) => this.rfind(predicate),
6712 Self::I9(this) => this.rfind(predicate),
6713 Self::I10(this) => this.rfind(predicate),
6714 }
6715 }
6716 fn rfold<B, F>(self, init: B, f: F) -> B
6717 where
6718 Self: Sized,
6719 F: FnMut(B, Self::Item) -> B,
6720 {
6721 match self {
6722 Self::I0(this) => this.rfold(init, f),
6723 Self::I1(this) => this.rfold(init, f),
6724 Self::I2(this) => this.rfold(init, f),
6725 Self::I3(this) => this.rfold(init, f),
6726 Self::I4(this) => this.rfold(init, f),
6727 Self::I5(this) => this.rfold(init, f),
6728 Self::I6(this) => this.rfold(init, f),
6729 Self::I7(this) => this.rfold(init, f),
6730 Self::I8(this) => this.rfold(init, f),
6731 Self::I9(this) => this.rfold(init, f),
6732 Self::I10(this) => this.rfold(init, f),
6733 }
6734 }
6735 }
6736 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> ExactSizeIterator
6737 for Iter11<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
6738 where
6739 I0: ExactSizeIterator<Item = Item>,
6740 I1: ExactSizeIterator<Item = Item>,
6741 I2: ExactSizeIterator<Item = Item>,
6742 I3: ExactSizeIterator<Item = Item>,
6743 I4: ExactSizeIterator<Item = Item>,
6744 I5: ExactSizeIterator<Item = Item>,
6745 I6: ExactSizeIterator<Item = Item>,
6746 I7: ExactSizeIterator<Item = Item>,
6747 I8: ExactSizeIterator<Item = Item>,
6748 I9: ExactSizeIterator<Item = Item>,
6749 I10: ExactSizeIterator<Item = Item>,
6750 {
6751 fn len(&self) -> usize {
6752 match self {
6753 Self::I0(this) => this.len(),
6754 Self::I1(this) => this.len(),
6755 Self::I2(this) => this.len(),
6756 Self::I3(this) => this.len(),
6757 Self::I4(this) => this.len(),
6758 Self::I5(this) => this.len(),
6759 Self::I6(this) => this.len(),
6760 Self::I7(this) => this.len(),
6761 Self::I8(this) => this.len(),
6762 Self::I9(this) => this.len(),
6763 Self::I10(this) => this.len(),
6764 }
6765 }
6766 }
6767 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> FusedIterator
6768 for Iter11<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
6769 where
6770 I0: FusedIterator<Item = Item>,
6771 I1: FusedIterator<Item = Item>,
6772 I2: FusedIterator<Item = Item>,
6773 I3: FusedIterator<Item = Item>,
6774 I4: FusedIterator<Item = Item>,
6775 I5: FusedIterator<Item = Item>,
6776 I6: FusedIterator<Item = Item>,
6777 I7: FusedIterator<Item = Item>,
6778 I8: FusedIterator<Item = Item>,
6779 I9: FusedIterator<Item = Item>,
6780 I10: FusedIterator<Item = Item>,
6781 {
6782 }
6783}
6784pub mod iter12 {
6785 use super::*;
6786 use core::iter::FusedIterator;
6787 #[derive(Debug, Clone, Copy)]
6788 pub enum Iter12<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> {
6789 I0(I0),
6790 I1(I1),
6791 I2(I2),
6792 I3(I3),
6793 I4(I4),
6794 I5(I5),
6795 I6(I6),
6796 I7(I7),
6797 I8(I8),
6798 I9(I9),
6799 I10(I10),
6800 I11(I11),
6801 }
6802 pub trait IntoIter0: IntoIterator {
6803 #[allow(clippy::type_complexity)]
6804 fn into_iter0<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>(
6805 self,
6806 ) -> Iter12<Self::IntoIter, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>;
6807 }
6808 impl<T: IntoIterator> IntoIter0 for T {
6809 #[allow(clippy::type_complexity)]
6810 fn into_iter0<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>(
6811 self,
6812 ) -> Iter12<Self::IntoIter, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> {
6813 Iter12::I0(self.into_iter())
6814 }
6815 }
6816 pub trait IntoIter1: IntoIterator {
6817 #[allow(clippy::type_complexity)]
6818 fn into_iter1<I0, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>(
6819 self,
6820 ) -> Iter12<I0, Self::IntoIter, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>;
6821 }
6822 impl<T: IntoIterator> IntoIter1 for T {
6823 #[allow(clippy::type_complexity)]
6824 fn into_iter1<I0, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>(
6825 self,
6826 ) -> Iter12<I0, Self::IntoIter, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> {
6827 Iter12::I1(self.into_iter())
6828 }
6829 }
6830 pub trait IntoIter2: IntoIterator {
6831 #[allow(clippy::type_complexity)]
6832 fn into_iter2<I0, I1, I3, I4, I5, I6, I7, I8, I9, I10, I11>(
6833 self,
6834 ) -> Iter12<I0, I1, Self::IntoIter, I3, I4, I5, I6, I7, I8, I9, I10, I11>;
6835 }
6836 impl<T: IntoIterator> IntoIter2 for T {
6837 #[allow(clippy::type_complexity)]
6838 fn into_iter2<I0, I1, I3, I4, I5, I6, I7, I8, I9, I10, I11>(
6839 self,
6840 ) -> Iter12<I0, I1, Self::IntoIter, I3, I4, I5, I6, I7, I8, I9, I10, I11> {
6841 Iter12::I2(self.into_iter())
6842 }
6843 }
6844 pub trait IntoIter3: IntoIterator {
6845 #[allow(clippy::type_complexity)]
6846 fn into_iter3<I0, I1, I2, I4, I5, I6, I7, I8, I9, I10, I11>(
6847 self,
6848 ) -> Iter12<I0, I1, I2, Self::IntoIter, I4, I5, I6, I7, I8, I9, I10, I11>;
6849 }
6850 impl<T: IntoIterator> IntoIter3 for T {
6851 #[allow(clippy::type_complexity)]
6852 fn into_iter3<I0, I1, I2, I4, I5, I6, I7, I8, I9, I10, I11>(
6853 self,
6854 ) -> Iter12<I0, I1, I2, Self::IntoIter, I4, I5, I6, I7, I8, I9, I10, I11> {
6855 Iter12::I3(self.into_iter())
6856 }
6857 }
6858 pub trait IntoIter4: IntoIterator {
6859 #[allow(clippy::type_complexity)]
6860 fn into_iter4<I0, I1, I2, I3, I5, I6, I7, I8, I9, I10, I11>(
6861 self,
6862 ) -> Iter12<I0, I1, I2, I3, Self::IntoIter, I5, I6, I7, I8, I9, I10, I11>;
6863 }
6864 impl<T: IntoIterator> IntoIter4 for T {
6865 #[allow(clippy::type_complexity)]
6866 fn into_iter4<I0, I1, I2, I3, I5, I6, I7, I8, I9, I10, I11>(
6867 self,
6868 ) -> Iter12<I0, I1, I2, I3, Self::IntoIter, I5, I6, I7, I8, I9, I10, I11> {
6869 Iter12::I4(self.into_iter())
6870 }
6871 }
6872 pub trait IntoIter5: IntoIterator {
6873 #[allow(clippy::type_complexity)]
6874 fn into_iter5<I0, I1, I2, I3, I4, I6, I7, I8, I9, I10, I11>(
6875 self,
6876 ) -> Iter12<I0, I1, I2, I3, I4, Self::IntoIter, I6, I7, I8, I9, I10, I11>;
6877 }
6878 impl<T: IntoIterator> IntoIter5 for T {
6879 #[allow(clippy::type_complexity)]
6880 fn into_iter5<I0, I1, I2, I3, I4, I6, I7, I8, I9, I10, I11>(
6881 self,
6882 ) -> Iter12<I0, I1, I2, I3, I4, Self::IntoIter, I6, I7, I8, I9, I10, I11> {
6883 Iter12::I5(self.into_iter())
6884 }
6885 }
6886 pub trait IntoIter6: IntoIterator {
6887 #[allow(clippy::type_complexity)]
6888 fn into_iter6<I0, I1, I2, I3, I4, I5, I7, I8, I9, I10, I11>(
6889 self,
6890 ) -> Iter12<I0, I1, I2, I3, I4, I5, Self::IntoIter, I7, I8, I9, I10, I11>;
6891 }
6892 impl<T: IntoIterator> IntoIter6 for T {
6893 #[allow(clippy::type_complexity)]
6894 fn into_iter6<I0, I1, I2, I3, I4, I5, I7, I8, I9, I10, I11>(
6895 self,
6896 ) -> Iter12<I0, I1, I2, I3, I4, I5, Self::IntoIter, I7, I8, I9, I10, I11> {
6897 Iter12::I6(self.into_iter())
6898 }
6899 }
6900 pub trait IntoIter7: IntoIterator {
6901 #[allow(clippy::type_complexity)]
6902 fn into_iter7<I0, I1, I2, I3, I4, I5, I6, I8, I9, I10, I11>(
6903 self,
6904 ) -> Iter12<I0, I1, I2, I3, I4, I5, I6, Self::IntoIter, I8, I9, I10, I11>;
6905 }
6906 impl<T: IntoIterator> IntoIter7 for T {
6907 #[allow(clippy::type_complexity)]
6908 fn into_iter7<I0, I1, I2, I3, I4, I5, I6, I8, I9, I10, I11>(
6909 self,
6910 ) -> Iter12<I0, I1, I2, I3, I4, I5, I6, Self::IntoIter, I8, I9, I10, I11> {
6911 Iter12::I7(self.into_iter())
6912 }
6913 }
6914 pub trait IntoIter8: IntoIterator {
6915 #[allow(clippy::type_complexity)]
6916 fn into_iter8<I0, I1, I2, I3, I4, I5, I6, I7, I9, I10, I11>(
6917 self,
6918 ) -> Iter12<I0, I1, I2, I3, I4, I5, I6, I7, Self::IntoIter, I9, I10, I11>;
6919 }
6920 impl<T: IntoIterator> IntoIter8 for T {
6921 #[allow(clippy::type_complexity)]
6922 fn into_iter8<I0, I1, I2, I3, I4, I5, I6, I7, I9, I10, I11>(
6923 self,
6924 ) -> Iter12<I0, I1, I2, I3, I4, I5, I6, I7, Self::IntoIter, I9, I10, I11> {
6925 Iter12::I8(self.into_iter())
6926 }
6927 }
6928 pub trait IntoIter9: IntoIterator {
6929 #[allow(clippy::type_complexity)]
6930 fn into_iter9<I0, I1, I2, I3, I4, I5, I6, I7, I8, I10, I11>(
6931 self,
6932 ) -> Iter12<I0, I1, I2, I3, I4, I5, I6, I7, I8, Self::IntoIter, I10, I11>;
6933 }
6934 impl<T: IntoIterator> IntoIter9 for T {
6935 #[allow(clippy::type_complexity)]
6936 fn into_iter9<I0, I1, I2, I3, I4, I5, I6, I7, I8, I10, I11>(
6937 self,
6938 ) -> Iter12<I0, I1, I2, I3, I4, I5, I6, I7, I8, Self::IntoIter, I10, I11> {
6939 Iter12::I9(self.into_iter())
6940 }
6941 }
6942 pub trait IntoIter10: IntoIterator {
6943 #[allow(clippy::type_complexity)]
6944 fn into_iter10<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I11>(
6945 self,
6946 ) -> Iter12<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, Self::IntoIter, I11>;
6947 }
6948 impl<T: IntoIterator> IntoIter10 for T {
6949 #[allow(clippy::type_complexity)]
6950 fn into_iter10<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I11>(
6951 self,
6952 ) -> Iter12<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, Self::IntoIter, I11> {
6953 Iter12::I10(self.into_iter())
6954 }
6955 }
6956 pub trait IntoIter11: IntoIterator {
6957 #[allow(clippy::type_complexity)]
6958 fn into_iter11<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>(
6959 self,
6960 ) -> Iter12<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, Self::IntoIter>;
6961 }
6962 impl<T: IntoIterator> IntoIter11 for T {
6963 #[allow(clippy::type_complexity)]
6964 fn into_iter11<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>(
6965 self,
6966 ) -> Iter12<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, Self::IntoIter> {
6967 Iter12::I11(self.into_iter())
6968 }
6969 }
6970 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> Iterator
6971 for Iter12<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
6972 where
6973 I0: Iterator<Item = Item>,
6974 I1: Iterator<Item = Item>,
6975 I2: Iterator<Item = Item>,
6976 I3: Iterator<Item = Item>,
6977 I4: Iterator<Item = Item>,
6978 I5: Iterator<Item = Item>,
6979 I6: Iterator<Item = Item>,
6980 I7: Iterator<Item = Item>,
6981 I8: Iterator<Item = Item>,
6982 I9: Iterator<Item = Item>,
6983 I10: Iterator<Item = Item>,
6984 I11: Iterator<Item = Item>,
6985 {
6986 type Item = Item;
6987 fn next(&mut self) -> Option<Self::Item> {
6988 match self {
6989 Self::I0(this) => this.next(),
6990 Self::I1(this) => this.next(),
6991 Self::I2(this) => this.next(),
6992 Self::I3(this) => this.next(),
6993 Self::I4(this) => this.next(),
6994 Self::I5(this) => this.next(),
6995 Self::I6(this) => this.next(),
6996 Self::I7(this) => this.next(),
6997 Self::I8(this) => this.next(),
6998 Self::I9(this) => this.next(),
6999 Self::I10(this) => this.next(),
7000 Self::I11(this) => this.next(),
7001 }
7002 }
7003 fn size_hint(&self) -> (usize, Option<usize>) {
7004 match self {
7005 Self::I0(this) => this.size_hint(),
7006 Self::I1(this) => this.size_hint(),
7007 Self::I2(this) => this.size_hint(),
7008 Self::I3(this) => this.size_hint(),
7009 Self::I4(this) => this.size_hint(),
7010 Self::I5(this) => this.size_hint(),
7011 Self::I6(this) => this.size_hint(),
7012 Self::I7(this) => this.size_hint(),
7013 Self::I8(this) => this.size_hint(),
7014 Self::I9(this) => this.size_hint(),
7015 Self::I10(this) => this.size_hint(),
7016 Self::I11(this) => this.size_hint(),
7017 }
7018 }
7019 fn count(self) -> usize
7020 where
7021 Self: Sized,
7022 {
7023 match self {
7024 Self::I0(this) => this.count(),
7025 Self::I1(this) => this.count(),
7026 Self::I2(this) => this.count(),
7027 Self::I3(this) => this.count(),
7028 Self::I4(this) => this.count(),
7029 Self::I5(this) => this.count(),
7030 Self::I6(this) => this.count(),
7031 Self::I7(this) => this.count(),
7032 Self::I8(this) => this.count(),
7033 Self::I9(this) => this.count(),
7034 Self::I10(this) => this.count(),
7035 Self::I11(this) => this.count(),
7036 }
7037 }
7038 fn last(self) -> Option<Self::Item>
7039 where
7040 Self: Sized,
7041 {
7042 match self {
7043 Self::I0(this) => this.last(),
7044 Self::I1(this) => this.last(),
7045 Self::I2(this) => this.last(),
7046 Self::I3(this) => this.last(),
7047 Self::I4(this) => this.last(),
7048 Self::I5(this) => this.last(),
7049 Self::I6(this) => this.last(),
7050 Self::I7(this) => this.last(),
7051 Self::I8(this) => this.last(),
7052 Self::I9(this) => this.last(),
7053 Self::I10(this) => this.last(),
7054 Self::I11(this) => this.last(),
7055 }
7056 }
7057 fn nth(&mut self, n: usize) -> Option<Self::Item> {
7058 match self {
7059 Self::I0(this) => this.nth(n),
7060 Self::I1(this) => this.nth(n),
7061 Self::I2(this) => this.nth(n),
7062 Self::I3(this) => this.nth(n),
7063 Self::I4(this) => this.nth(n),
7064 Self::I5(this) => this.nth(n),
7065 Self::I6(this) => this.nth(n),
7066 Self::I7(this) => this.nth(n),
7067 Self::I8(this) => this.nth(n),
7068 Self::I9(this) => this.nth(n),
7069 Self::I10(this) => this.nth(n),
7070 Self::I11(this) => this.nth(n),
7071 }
7072 }
7073 fn for_each<F>(self, f: F)
7074 where
7075 Self: Sized,
7076 F: FnMut(Self::Item),
7077 {
7078 match self {
7079 Self::I0(this) => this.for_each(f),
7080 Self::I1(this) => this.for_each(f),
7081 Self::I2(this) => this.for_each(f),
7082 Self::I3(this) => this.for_each(f),
7083 Self::I4(this) => this.for_each(f),
7084 Self::I5(this) => this.for_each(f),
7085 Self::I6(this) => this.for_each(f),
7086 Self::I7(this) => this.for_each(f),
7087 Self::I8(this) => this.for_each(f),
7088 Self::I9(this) => this.for_each(f),
7089 Self::I10(this) => this.for_each(f),
7090 Self::I11(this) => this.for_each(f),
7091 }
7092 }
7093 fn collect<B: FromIterator<Self::Item>>(self) -> B
7094 where
7095 Self: Sized,
7096 {
7097 match self {
7098 Self::I0(this) => this.collect(),
7099 Self::I1(this) => this.collect(),
7100 Self::I2(this) => this.collect(),
7101 Self::I3(this) => this.collect(),
7102 Self::I4(this) => this.collect(),
7103 Self::I5(this) => this.collect(),
7104 Self::I6(this) => this.collect(),
7105 Self::I7(this) => this.collect(),
7106 Self::I8(this) => this.collect(),
7107 Self::I9(this) => this.collect(),
7108 Self::I10(this) => this.collect(),
7109 Self::I11(this) => this.collect(),
7110 }
7111 }
7112 fn partition<B, F>(self, f: F) -> (B, B)
7113 where
7114 Self: Sized,
7115 B: Default + Extend<Self::Item>,
7116 F: FnMut(&Self::Item) -> bool,
7117 {
7118 match self {
7119 Self::I0(this) => this.partition(f),
7120 Self::I1(this) => this.partition(f),
7121 Self::I2(this) => this.partition(f),
7122 Self::I3(this) => this.partition(f),
7123 Self::I4(this) => this.partition(f),
7124 Self::I5(this) => this.partition(f),
7125 Self::I6(this) => this.partition(f),
7126 Self::I7(this) => this.partition(f),
7127 Self::I8(this) => this.partition(f),
7128 Self::I9(this) => this.partition(f),
7129 Self::I10(this) => this.partition(f),
7130 Self::I11(this) => this.partition(f),
7131 }
7132 }
7133 fn fold<B, F>(self, init: B, f: F) -> B
7134 where
7135 Self: Sized,
7136 F: FnMut(B, Self::Item) -> B,
7137 {
7138 match self {
7139 Self::I0(this) => this.fold(init, f),
7140 Self::I1(this) => this.fold(init, f),
7141 Self::I2(this) => this.fold(init, f),
7142 Self::I3(this) => this.fold(init, f),
7143 Self::I4(this) => this.fold(init, f),
7144 Self::I5(this) => this.fold(init, f),
7145 Self::I6(this) => this.fold(init, f),
7146 Self::I7(this) => this.fold(init, f),
7147 Self::I8(this) => this.fold(init, f),
7148 Self::I9(this) => this.fold(init, f),
7149 Self::I10(this) => this.fold(init, f),
7150 Self::I11(this) => this.fold(init, f),
7151 }
7152 }
7153 fn reduce<F>(self, f: F) -> Option<Self::Item>
7154 where
7155 Self: Sized,
7156 F: FnMut(Self::Item, Self::Item) -> Self::Item,
7157 {
7158 match self {
7159 Self::I0(this) => this.reduce(f),
7160 Self::I1(this) => this.reduce(f),
7161 Self::I2(this) => this.reduce(f),
7162 Self::I3(this) => this.reduce(f),
7163 Self::I4(this) => this.reduce(f),
7164 Self::I5(this) => this.reduce(f),
7165 Self::I6(this) => this.reduce(f),
7166 Self::I7(this) => this.reduce(f),
7167 Self::I8(this) => this.reduce(f),
7168 Self::I9(this) => this.reduce(f),
7169 Self::I10(this) => this.reduce(f),
7170 Self::I11(this) => this.reduce(f),
7171 }
7172 }
7173 fn all<F>(&mut self, f: F) -> bool
7174 where
7175 Self: Sized,
7176 F: FnMut(Self::Item) -> bool,
7177 {
7178 match self {
7179 Self::I0(this) => this.all(f),
7180 Self::I1(this) => this.all(f),
7181 Self::I2(this) => this.all(f),
7182 Self::I3(this) => this.all(f),
7183 Self::I4(this) => this.all(f),
7184 Self::I5(this) => this.all(f),
7185 Self::I6(this) => this.all(f),
7186 Self::I7(this) => this.all(f),
7187 Self::I8(this) => this.all(f),
7188 Self::I9(this) => this.all(f),
7189 Self::I10(this) => this.all(f),
7190 Self::I11(this) => this.all(f),
7191 }
7192 }
7193 fn any<F>(&mut self, f: F) -> bool
7194 where
7195 Self: Sized,
7196 F: FnMut(Self::Item) -> bool,
7197 {
7198 match self {
7199 Self::I0(this) => this.any(f),
7200 Self::I1(this) => this.any(f),
7201 Self::I2(this) => this.any(f),
7202 Self::I3(this) => this.any(f),
7203 Self::I4(this) => this.any(f),
7204 Self::I5(this) => this.any(f),
7205 Self::I6(this) => this.any(f),
7206 Self::I7(this) => this.any(f),
7207 Self::I8(this) => this.any(f),
7208 Self::I9(this) => this.any(f),
7209 Self::I10(this) => this.any(f),
7210 Self::I11(this) => this.any(f),
7211 }
7212 }
7213 fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
7214 where
7215 Self: Sized,
7216 P: FnMut(&Self::Item) -> bool,
7217 {
7218 match self {
7219 Self::I0(this) => this.find(predicate),
7220 Self::I1(this) => this.find(predicate),
7221 Self::I2(this) => this.find(predicate),
7222 Self::I3(this) => this.find(predicate),
7223 Self::I4(this) => this.find(predicate),
7224 Self::I5(this) => this.find(predicate),
7225 Self::I6(this) => this.find(predicate),
7226 Self::I7(this) => this.find(predicate),
7227 Self::I8(this) => this.find(predicate),
7228 Self::I9(this) => this.find(predicate),
7229 Self::I10(this) => this.find(predicate),
7230 Self::I11(this) => this.find(predicate),
7231 }
7232 }
7233 fn find_map<B, F>(&mut self, f: F) -> Option<B>
7234 where
7235 Self: Sized,
7236 F: FnMut(Self::Item) -> Option<B>,
7237 {
7238 match self {
7239 Self::I0(this) => this.find_map(f),
7240 Self::I1(this) => this.find_map(f),
7241 Self::I2(this) => this.find_map(f),
7242 Self::I3(this) => this.find_map(f),
7243 Self::I4(this) => this.find_map(f),
7244 Self::I5(this) => this.find_map(f),
7245 Self::I6(this) => this.find_map(f),
7246 Self::I7(this) => this.find_map(f),
7247 Self::I8(this) => this.find_map(f),
7248 Self::I9(this) => this.find_map(f),
7249 Self::I10(this) => this.find_map(f),
7250 Self::I11(this) => this.find_map(f),
7251 }
7252 }
7253 fn position<P>(&mut self, predicate: P) -> Option<usize>
7254 where
7255 Self: Sized,
7256 P: FnMut(Self::Item) -> bool,
7257 {
7258 match self {
7259 Self::I0(this) => this.position(predicate),
7260 Self::I1(this) => this.position(predicate),
7261 Self::I2(this) => this.position(predicate),
7262 Self::I3(this) => this.position(predicate),
7263 Self::I4(this) => this.position(predicate),
7264 Self::I5(this) => this.position(predicate),
7265 Self::I6(this) => this.position(predicate),
7266 Self::I7(this) => this.position(predicate),
7267 Self::I8(this) => this.position(predicate),
7268 Self::I9(this) => this.position(predicate),
7269 Self::I10(this) => this.position(predicate),
7270 Self::I11(this) => this.position(predicate),
7271 }
7272 }
7273 fn max(self) -> Option<Self::Item>
7274 where
7275 Self: Sized,
7276 Self::Item: Ord,
7277 {
7278 match self {
7279 Self::I0(this) => this.max(),
7280 Self::I1(this) => this.max(),
7281 Self::I2(this) => this.max(),
7282 Self::I3(this) => this.max(),
7283 Self::I4(this) => this.max(),
7284 Self::I5(this) => this.max(),
7285 Self::I6(this) => this.max(),
7286 Self::I7(this) => this.max(),
7287 Self::I8(this) => this.max(),
7288 Self::I9(this) => this.max(),
7289 Self::I10(this) => this.max(),
7290 Self::I11(this) => this.max(),
7291 }
7292 }
7293 fn min(self) -> Option<Self::Item>
7294 where
7295 Self: Sized,
7296 Self::Item: Ord,
7297 {
7298 match self {
7299 Self::I0(this) => this.min(),
7300 Self::I1(this) => this.min(),
7301 Self::I2(this) => this.min(),
7302 Self::I3(this) => this.min(),
7303 Self::I4(this) => this.min(),
7304 Self::I5(this) => this.min(),
7305 Self::I6(this) => this.min(),
7306 Self::I7(this) => this.min(),
7307 Self::I8(this) => this.min(),
7308 Self::I9(this) => this.min(),
7309 Self::I10(this) => this.min(),
7310 Self::I11(this) => this.min(),
7311 }
7312 }
7313 fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
7314 where
7315 Self: Sized,
7316 F: FnMut(&Self::Item) -> B,
7317 {
7318 match self {
7319 Self::I0(this) => this.max_by_key(f),
7320 Self::I1(this) => this.max_by_key(f),
7321 Self::I2(this) => this.max_by_key(f),
7322 Self::I3(this) => this.max_by_key(f),
7323 Self::I4(this) => this.max_by_key(f),
7324 Self::I5(this) => this.max_by_key(f),
7325 Self::I6(this) => this.max_by_key(f),
7326 Self::I7(this) => this.max_by_key(f),
7327 Self::I8(this) => this.max_by_key(f),
7328 Self::I9(this) => this.max_by_key(f),
7329 Self::I10(this) => this.max_by_key(f),
7330 Self::I11(this) => this.max_by_key(f),
7331 }
7332 }
7333 fn max_by<F>(self, compare: F) -> Option<Self::Item>
7334 where
7335 Self: Sized,
7336 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
7337 {
7338 match self {
7339 Self::I0(this) => this.max_by(compare),
7340 Self::I1(this) => this.max_by(compare),
7341 Self::I2(this) => this.max_by(compare),
7342 Self::I3(this) => this.max_by(compare),
7343 Self::I4(this) => this.max_by(compare),
7344 Self::I5(this) => this.max_by(compare),
7345 Self::I6(this) => this.max_by(compare),
7346 Self::I7(this) => this.max_by(compare),
7347 Self::I8(this) => this.max_by(compare),
7348 Self::I9(this) => this.max_by(compare),
7349 Self::I10(this) => this.max_by(compare),
7350 Self::I11(this) => this.max_by(compare),
7351 }
7352 }
7353 fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
7354 where
7355 Self: Sized,
7356 F: FnMut(&Self::Item) -> B,
7357 {
7358 match self {
7359 Self::I0(this) => this.min_by_key(f),
7360 Self::I1(this) => this.min_by_key(f),
7361 Self::I2(this) => this.min_by_key(f),
7362 Self::I3(this) => this.min_by_key(f),
7363 Self::I4(this) => this.min_by_key(f),
7364 Self::I5(this) => this.min_by_key(f),
7365 Self::I6(this) => this.min_by_key(f),
7366 Self::I7(this) => this.min_by_key(f),
7367 Self::I8(this) => this.min_by_key(f),
7368 Self::I9(this) => this.min_by_key(f),
7369 Self::I10(this) => this.min_by_key(f),
7370 Self::I11(this) => this.min_by_key(f),
7371 }
7372 }
7373 fn min_by<F>(self, compare: F) -> Option<Self::Item>
7374 where
7375 Self: Sized,
7376 F: FnMut(&Self::Item, &Self::Item) -> Ordering,
7377 {
7378 match self {
7379 Self::I0(this) => this.min_by(compare),
7380 Self::I1(this) => this.min_by(compare),
7381 Self::I2(this) => this.min_by(compare),
7382 Self::I3(this) => this.min_by(compare),
7383 Self::I4(this) => this.min_by(compare),
7384 Self::I5(this) => this.min_by(compare),
7385 Self::I6(this) => this.min_by(compare),
7386 Self::I7(this) => this.min_by(compare),
7387 Self::I8(this) => this.min_by(compare),
7388 Self::I9(this) => this.min_by(compare),
7389 Self::I10(this) => this.min_by(compare),
7390 Self::I11(this) => this.min_by(compare),
7391 }
7392 }
7393 fn sum<S>(self) -> S
7394 where
7395 Self: Sized,
7396 S: Sum<Self::Item>,
7397 {
7398 match self {
7399 Self::I0(this) => this.sum(),
7400 Self::I1(this) => this.sum(),
7401 Self::I2(this) => this.sum(),
7402 Self::I3(this) => this.sum(),
7403 Self::I4(this) => this.sum(),
7404 Self::I5(this) => this.sum(),
7405 Self::I6(this) => this.sum(),
7406 Self::I7(this) => this.sum(),
7407 Self::I8(this) => this.sum(),
7408 Self::I9(this) => this.sum(),
7409 Self::I10(this) => this.sum(),
7410 Self::I11(this) => this.sum(),
7411 }
7412 }
7413 fn product<P>(self) -> P
7414 where
7415 Self: Sized,
7416 P: Product<Self::Item>,
7417 {
7418 match self {
7419 Self::I0(this) => this.product(),
7420 Self::I1(this) => this.product(),
7421 Self::I2(this) => this.product(),
7422 Self::I3(this) => this.product(),
7423 Self::I4(this) => this.product(),
7424 Self::I5(this) => this.product(),
7425 Self::I6(this) => this.product(),
7426 Self::I7(this) => this.product(),
7427 Self::I8(this) => this.product(),
7428 Self::I9(this) => this.product(),
7429 Self::I10(this) => this.product(),
7430 Self::I11(this) => this.product(),
7431 }
7432 }
7433 fn cmp<I>(self, other: I) -> Ordering
7434 where
7435 I: IntoIterator<Item = Self::Item>,
7436 Self::Item: Ord,
7437 Self: Sized,
7438 {
7439 match self {
7440 Self::I0(this) => this.cmp(other),
7441 Self::I1(this) => this.cmp(other),
7442 Self::I2(this) => this.cmp(other),
7443 Self::I3(this) => this.cmp(other),
7444 Self::I4(this) => this.cmp(other),
7445 Self::I5(this) => this.cmp(other),
7446 Self::I6(this) => this.cmp(other),
7447 Self::I7(this) => this.cmp(other),
7448 Self::I8(this) => this.cmp(other),
7449 Self::I9(this) => this.cmp(other),
7450 Self::I10(this) => this.cmp(other),
7451 Self::I11(this) => this.cmp(other),
7452 }
7453 }
7454 fn partial_cmp<I>(self, other: I) -> Option<Ordering>
7455 where
7456 I: IntoIterator,
7457 Self::Item: PartialOrd<I::Item>,
7458 Self: Sized,
7459 {
7460 match self {
7461 Self::I0(this) => this.partial_cmp(other),
7462 Self::I1(this) => this.partial_cmp(other),
7463 Self::I2(this) => this.partial_cmp(other),
7464 Self::I3(this) => this.partial_cmp(other),
7465 Self::I4(this) => this.partial_cmp(other),
7466 Self::I5(this) => this.partial_cmp(other),
7467 Self::I6(this) => this.partial_cmp(other),
7468 Self::I7(this) => this.partial_cmp(other),
7469 Self::I8(this) => this.partial_cmp(other),
7470 Self::I9(this) => this.partial_cmp(other),
7471 Self::I10(this) => this.partial_cmp(other),
7472 Self::I11(this) => this.partial_cmp(other),
7473 }
7474 }
7475 fn eq<I>(self, other: I) -> bool
7476 where
7477 I: IntoIterator,
7478 Self::Item: PartialEq<I::Item>,
7479 Self: Sized,
7480 {
7481 match self {
7482 Self::I0(this) => this.eq(other),
7483 Self::I1(this) => this.eq(other),
7484 Self::I2(this) => this.eq(other),
7485 Self::I3(this) => this.eq(other),
7486 Self::I4(this) => this.eq(other),
7487 Self::I5(this) => this.eq(other),
7488 Self::I6(this) => this.eq(other),
7489 Self::I7(this) => this.eq(other),
7490 Self::I8(this) => this.eq(other),
7491 Self::I9(this) => this.eq(other),
7492 Self::I10(this) => this.eq(other),
7493 Self::I11(this) => this.eq(other),
7494 }
7495 }
7496 fn ne<I>(self, other: I) -> bool
7497 where
7498 I: IntoIterator,
7499 Self::Item: PartialEq<I::Item>,
7500 Self: Sized,
7501 {
7502 match self {
7503 Self::I0(this) => this.ne(other),
7504 Self::I1(this) => this.ne(other),
7505 Self::I2(this) => this.ne(other),
7506 Self::I3(this) => this.ne(other),
7507 Self::I4(this) => this.ne(other),
7508 Self::I5(this) => this.ne(other),
7509 Self::I6(this) => this.ne(other),
7510 Self::I7(this) => this.ne(other),
7511 Self::I8(this) => this.ne(other),
7512 Self::I9(this) => this.ne(other),
7513 Self::I10(this) => this.ne(other),
7514 Self::I11(this) => this.ne(other),
7515 }
7516 }
7517 fn lt<I>(self, other: I) -> bool
7518 where
7519 I: IntoIterator,
7520 Self::Item: PartialOrd<I::Item>,
7521 Self: Sized,
7522 {
7523 match self {
7524 Self::I0(this) => this.lt(other),
7525 Self::I1(this) => this.lt(other),
7526 Self::I2(this) => this.lt(other),
7527 Self::I3(this) => this.lt(other),
7528 Self::I4(this) => this.lt(other),
7529 Self::I5(this) => this.lt(other),
7530 Self::I6(this) => this.lt(other),
7531 Self::I7(this) => this.lt(other),
7532 Self::I8(this) => this.lt(other),
7533 Self::I9(this) => this.lt(other),
7534 Self::I10(this) => this.lt(other),
7535 Self::I11(this) => this.lt(other),
7536 }
7537 }
7538 fn le<I>(self, other: I) -> bool
7539 where
7540 I: IntoIterator,
7541 Self::Item: PartialOrd<I::Item>,
7542 Self: Sized,
7543 {
7544 match self {
7545 Self::I0(this) => this.le(other),
7546 Self::I1(this) => this.le(other),
7547 Self::I2(this) => this.le(other),
7548 Self::I3(this) => this.le(other),
7549 Self::I4(this) => this.le(other),
7550 Self::I5(this) => this.le(other),
7551 Self::I6(this) => this.le(other),
7552 Self::I7(this) => this.le(other),
7553 Self::I8(this) => this.le(other),
7554 Self::I9(this) => this.le(other),
7555 Self::I10(this) => this.le(other),
7556 Self::I11(this) => this.le(other),
7557 }
7558 }
7559 fn gt<I>(self, other: I) -> bool
7560 where
7561 I: IntoIterator,
7562 Self::Item: PartialOrd<I::Item>,
7563 Self: Sized,
7564 {
7565 match self {
7566 Self::I0(this) => this.gt(other),
7567 Self::I1(this) => this.gt(other),
7568 Self::I2(this) => this.gt(other),
7569 Self::I3(this) => this.gt(other),
7570 Self::I4(this) => this.gt(other),
7571 Self::I5(this) => this.gt(other),
7572 Self::I6(this) => this.gt(other),
7573 Self::I7(this) => this.gt(other),
7574 Self::I8(this) => this.gt(other),
7575 Self::I9(this) => this.gt(other),
7576 Self::I10(this) => this.gt(other),
7577 Self::I11(this) => this.gt(other),
7578 }
7579 }
7580 fn ge<I>(self, other: I) -> bool
7581 where
7582 I: IntoIterator,
7583 Self::Item: PartialOrd<I::Item>,
7584 Self: Sized,
7585 {
7586 match self {
7587 Self::I0(this) => this.ge(other),
7588 Self::I1(this) => this.ge(other),
7589 Self::I2(this) => this.ge(other),
7590 Self::I3(this) => this.ge(other),
7591 Self::I4(this) => this.ge(other),
7592 Self::I5(this) => this.ge(other),
7593 Self::I6(this) => this.ge(other),
7594 Self::I7(this) => this.ge(other),
7595 Self::I8(this) => this.ge(other),
7596 Self::I9(this) => this.ge(other),
7597 Self::I10(this) => this.ge(other),
7598 Self::I11(this) => this.ge(other),
7599 }
7600 }
7601 }
7602 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> DoubleEndedIterator
7603 for Iter12<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
7604 where
7605 I0: DoubleEndedIterator<Item = Item>,
7606 I1: DoubleEndedIterator<Item = Item>,
7607 I2: DoubleEndedIterator<Item = Item>,
7608 I3: DoubleEndedIterator<Item = Item>,
7609 I4: DoubleEndedIterator<Item = Item>,
7610 I5: DoubleEndedIterator<Item = Item>,
7611 I6: DoubleEndedIterator<Item = Item>,
7612 I7: DoubleEndedIterator<Item = Item>,
7613 I8: DoubleEndedIterator<Item = Item>,
7614 I9: DoubleEndedIterator<Item = Item>,
7615 I10: DoubleEndedIterator<Item = Item>,
7616 I11: DoubleEndedIterator<Item = Item>,
7617 {
7618 fn next_back(&mut self) -> Option<Self::Item> {
7619 match self {
7620 Self::I0(this) => this.next_back(),
7621 Self::I1(this) => this.next_back(),
7622 Self::I2(this) => this.next_back(),
7623 Self::I3(this) => this.next_back(),
7624 Self::I4(this) => this.next_back(),
7625 Self::I5(this) => this.next_back(),
7626 Self::I6(this) => this.next_back(),
7627 Self::I7(this) => this.next_back(),
7628 Self::I8(this) => this.next_back(),
7629 Self::I9(this) => this.next_back(),
7630 Self::I10(this) => this.next_back(),
7631 Self::I11(this) => this.next_back(),
7632 }
7633 }
7634 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
7635 match self {
7636 Self::I0(this) => this.nth_back(n),
7637 Self::I1(this) => this.nth_back(n),
7638 Self::I2(this) => this.nth_back(n),
7639 Self::I3(this) => this.nth_back(n),
7640 Self::I4(this) => this.nth_back(n),
7641 Self::I5(this) => this.nth_back(n),
7642 Self::I6(this) => this.nth_back(n),
7643 Self::I7(this) => this.nth_back(n),
7644 Self::I8(this) => this.nth_back(n),
7645 Self::I9(this) => this.nth_back(n),
7646 Self::I10(this) => this.nth_back(n),
7647 Self::I11(this) => this.nth_back(n),
7648 }
7649 }
7650 fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
7651 where
7652 P: FnMut(&Self::Item) -> bool,
7653 {
7654 match self {
7655 Self::I0(this) => this.rfind(predicate),
7656 Self::I1(this) => this.rfind(predicate),
7657 Self::I2(this) => this.rfind(predicate),
7658 Self::I3(this) => this.rfind(predicate),
7659 Self::I4(this) => this.rfind(predicate),
7660 Self::I5(this) => this.rfind(predicate),
7661 Self::I6(this) => this.rfind(predicate),
7662 Self::I7(this) => this.rfind(predicate),
7663 Self::I8(this) => this.rfind(predicate),
7664 Self::I9(this) => this.rfind(predicate),
7665 Self::I10(this) => this.rfind(predicate),
7666 Self::I11(this) => this.rfind(predicate),
7667 }
7668 }
7669 fn rfold<B, F>(self, init: B, f: F) -> B
7670 where
7671 Self: Sized,
7672 F: FnMut(B, Self::Item) -> B,
7673 {
7674 match self {
7675 Self::I0(this) => this.rfold(init, f),
7676 Self::I1(this) => this.rfold(init, f),
7677 Self::I2(this) => this.rfold(init, f),
7678 Self::I3(this) => this.rfold(init, f),
7679 Self::I4(this) => this.rfold(init, f),
7680 Self::I5(this) => this.rfold(init, f),
7681 Self::I6(this) => this.rfold(init, f),
7682 Self::I7(this) => this.rfold(init, f),
7683 Self::I8(this) => this.rfold(init, f),
7684 Self::I9(this) => this.rfold(init, f),
7685 Self::I10(this) => this.rfold(init, f),
7686 Self::I11(this) => this.rfold(init, f),
7687 }
7688 }
7689 }
7690 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> ExactSizeIterator
7691 for Iter12<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
7692 where
7693 I0: ExactSizeIterator<Item = Item>,
7694 I1: ExactSizeIterator<Item = Item>,
7695 I2: ExactSizeIterator<Item = Item>,
7696 I3: ExactSizeIterator<Item = Item>,
7697 I4: ExactSizeIterator<Item = Item>,
7698 I5: ExactSizeIterator<Item = Item>,
7699 I6: ExactSizeIterator<Item = Item>,
7700 I7: ExactSizeIterator<Item = Item>,
7701 I8: ExactSizeIterator<Item = Item>,
7702 I9: ExactSizeIterator<Item = Item>,
7703 I10: ExactSizeIterator<Item = Item>,
7704 I11: ExactSizeIterator<Item = Item>,
7705 {
7706 fn len(&self) -> usize {
7707 match self {
7708 Self::I0(this) => this.len(),
7709 Self::I1(this) => this.len(),
7710 Self::I2(this) => this.len(),
7711 Self::I3(this) => this.len(),
7712 Self::I4(this) => this.len(),
7713 Self::I5(this) => this.len(),
7714 Self::I6(this) => this.len(),
7715 Self::I7(this) => this.len(),
7716 Self::I8(this) => this.len(),
7717 Self::I9(this) => this.len(),
7718 Self::I10(this) => this.len(),
7719 Self::I11(this) => this.len(),
7720 }
7721 }
7722 }
7723 impl<Item, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> FusedIterator
7724 for Iter12<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
7725 where
7726 I0: FusedIterator<Item = Item>,
7727 I1: FusedIterator<Item = Item>,
7728 I2: FusedIterator<Item = Item>,
7729 I3: FusedIterator<Item = Item>,
7730 I4: FusedIterator<Item = Item>,
7731 I5: FusedIterator<Item = Item>,
7732 I6: FusedIterator<Item = Item>,
7733 I7: FusedIterator<Item = Item>,
7734 I8: FusedIterator<Item = Item>,
7735 I9: FusedIterator<Item = Item>,
7736 I10: FusedIterator<Item = Item>,
7737 I11: FusedIterator<Item = Item>,
7738 {
7739 }
7740}