1#[derive(Debug, Clone)]
4pub struct Tuple2Iter<'a, T>([&'a T; 2], Range<usize>);
5impl<'a, T> Tuple2Iter<'a, T> {
6 #[inline]
7 pub fn new(t: &'a (T, T)) -> Self {
8 Self([&t.0, &t.1], 0..2)
9 }
10}
11impl<'a, T> Iterator for Tuple2Iter<'a, T> {
12 type Item = &'a T;
13 #[inline]
14 fn next(&mut self) -> Option<Self::Item> {
15 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
16 }
17 #[inline]
18 fn size_hint(&self) -> (usize, Option<usize>) {
19 let len = self.len();
20 (len, Some(len))
21 }
22 #[inline]
23 fn count(self) -> usize {
24 self.len()
25 }
26 #[inline]
27 fn last(mut self) -> Option<Self::Item> {
28 self.next_back()
29 }
30}
31impl<'a, T> DoubleEndedIterator for Tuple2Iter<'a, T> {
32 #[inline]
33 fn next_back(&mut self) -> Option<Self::Item> {
34 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
35 }
36}
37impl<'a, T> ExactSizeIterator for Tuple2Iter<'a, T> {
38 #[inline]
39 fn len(&self) -> usize {
40 self.1.end - self.1.start
41 }
42}
43impl<'a, T> FusedIterator for Tuple2Iter<'a, T> {}
44impl<'a, T: 'a> TupleIter<'a> for (T, T) {
45 type Iter = Tuple2Iter<'a, T>;
46 #[inline]
47 fn iter(&'a self) -> Self::Iter {
48 Tuple2Iter::new(self)
49 }
50}
51#[derive(Debug)]
52pub struct Tuple2IntoIter<T>([MaybeUninit<T>; 2], Range<usize>);
53impl<T> Tuple2IntoIter<T> {
54 #[inline]
55 pub fn new(t: (T, T)) -> Self {
56 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1)], 0..2)
57 }
58}
59impl<T> Iterator for Tuple2IntoIter<T> {
60 type Item = T;
61 #[inline]
62 fn next(&mut self) -> Option<Self::Item> {
63 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
64 }
65 #[inline]
66 fn size_hint(&self) -> (usize, Option<usize>) {
67 let len = self.len();
68 (len, Some(len))
69 }
70 #[inline]
71 fn count(self) -> usize {
72 self.len()
73 }
74 #[inline]
75 fn last(mut self) -> Option<Self::Item> {
76 self.next_back()
77 }
78}
79impl<T> DoubleEndedIterator for Tuple2IntoIter<T> {
80 fn next_back(&mut self) -> Option<Self::Item> {
81 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
82 }
83}
84impl<T> ExactSizeIterator for Tuple2IntoIter<T> {
85 #[inline]
86 fn len(&self) -> usize {
87 self.1.end - self.1.start
88 }
89}
90impl<T> FusedIterator for Tuple2IntoIter<T> {}
91impl<T> TupleIntoIter for (T, T) {
92 type Iter = Tuple2IntoIter<T>;
93 #[inline]
94 fn into_iter(self) -> Self::Iter {
95 Tuple2IntoIter::new(self)
96 }
97}
98impl<T> Drop for Tuple2IntoIter<T> {
99 fn drop(&mut self) {
100 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
101 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
102 unsafe { core::ptr::drop_in_place(slice) }
103 }
104}
105impl<T> TupleFromIter<T> for (T, T) {
106 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
107 let mut iter = iter.into_iter();
108 (iter.next().unwrap(), iter.next().unwrap())
109 }
110}
111impl<T> TupleTryFromIter<T> for (T, T) {
112 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
113 let mut iter = iter.into_iter();
114 Some((iter.next()?, iter.next()?))
115 }
116}
117impl<T> TupleFromIterTry<T> for (T, T) {
118 type OutTuple = (Option<T>, Option<T>);
119 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
120 let mut iter = iter.into_iter();
121 (iter.next(), iter.next())
122 }
123}
124#[derive(Debug, Clone)]
125pub struct Tuple3Iter<'a, T>([&'a T; 3], Range<usize>);
126impl<'a, T> Tuple3Iter<'a, T> {
127 #[inline]
128 pub fn new(t: &'a (T, T, T)) -> Self {
129 Self([&t.0, &t.1, &t.2], 0..3)
130 }
131}
132impl<'a, T> Iterator for Tuple3Iter<'a, T> {
133 type Item = &'a T;
134 #[inline]
135 fn next(&mut self) -> Option<Self::Item> {
136 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
137 }
138 #[inline]
139 fn size_hint(&self) -> (usize, Option<usize>) {
140 let len = self.len();
141 (len, Some(len))
142 }
143 #[inline]
144 fn count(self) -> usize {
145 self.len()
146 }
147 #[inline]
148 fn last(mut self) -> Option<Self::Item> {
149 self.next_back()
150 }
151}
152impl<'a, T> DoubleEndedIterator for Tuple3Iter<'a, T> {
153 #[inline]
154 fn next_back(&mut self) -> Option<Self::Item> {
155 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
156 }
157}
158impl<'a, T> ExactSizeIterator for Tuple3Iter<'a, T> {
159 #[inline]
160 fn len(&self) -> usize {
161 self.1.end - self.1.start
162 }
163}
164impl<'a, T> FusedIterator for Tuple3Iter<'a, T> {}
165impl<'a, T: 'a> TupleIter<'a> for (T, T, T) {
166 type Iter = Tuple3Iter<'a, T>;
167 #[inline]
168 fn iter(&'a self) -> Self::Iter {
169 Tuple3Iter::new(self)
170 }
171}
172#[derive(Debug)]
173pub struct Tuple3IntoIter<T>([MaybeUninit<T>; 3], Range<usize>);
174impl<T> Tuple3IntoIter<T> {
175 #[inline]
176 pub fn new(t: (T, T, T)) -> Self {
177 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2)], 0..3)
178 }
179}
180impl<T> Iterator for Tuple3IntoIter<T> {
181 type Item = T;
182 #[inline]
183 fn next(&mut self) -> Option<Self::Item> {
184 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
185 }
186 #[inline]
187 fn size_hint(&self) -> (usize, Option<usize>) {
188 let len = self.len();
189 (len, Some(len))
190 }
191 #[inline]
192 fn count(self) -> usize {
193 self.len()
194 }
195 #[inline]
196 fn last(mut self) -> Option<Self::Item> {
197 self.next_back()
198 }
199}
200impl<T> DoubleEndedIterator for Tuple3IntoIter<T> {
201 fn next_back(&mut self) -> Option<Self::Item> {
202 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
203 }
204}
205impl<T> ExactSizeIterator for Tuple3IntoIter<T> {
206 #[inline]
207 fn len(&self) -> usize {
208 self.1.end - self.1.start
209 }
210}
211impl<T> FusedIterator for Tuple3IntoIter<T> {}
212impl<T> TupleIntoIter for (T, T, T) {
213 type Iter = Tuple3IntoIter<T>;
214 #[inline]
215 fn into_iter(self) -> Self::Iter {
216 Tuple3IntoIter::new(self)
217 }
218}
219impl<T> Drop for Tuple3IntoIter<T> {
220 fn drop(&mut self) {
221 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
222 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
223 unsafe { core::ptr::drop_in_place(slice) }
224 }
225}
226impl<T> TupleFromIter<T> for (T, T, T) {
227 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
228 let mut iter = iter.into_iter();
229 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
230 }
231}
232impl<T> TupleTryFromIter<T> for (T, T, T) {
233 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
234 let mut iter = iter.into_iter();
235 Some((iter.next()?, iter.next()?, iter.next()?))
236 }
237}
238impl<T> TupleFromIterTry<T> for (T, T, T) {
239 type OutTuple = (Option<T>, Option<T>, Option<T>);
240 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
241 let mut iter = iter.into_iter();
242 (iter.next(), iter.next(), iter.next())
243 }
244}
245#[derive(Debug, Clone)]
246pub struct Tuple4Iter<'a, T>([&'a T; 4], Range<usize>);
247impl<'a, T> Tuple4Iter<'a, T> {
248 #[inline]
249 pub fn new(t: &'a (T, T, T, T)) -> Self {
250 Self([&t.0, &t.1, &t.2, &t.3], 0..4)
251 }
252}
253impl<'a, T> Iterator for Tuple4Iter<'a, T> {
254 type Item = &'a T;
255 #[inline]
256 fn next(&mut self) -> Option<Self::Item> {
257 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
258 }
259 #[inline]
260 fn size_hint(&self) -> (usize, Option<usize>) {
261 let len = self.len();
262 (len, Some(len))
263 }
264 #[inline]
265 fn count(self) -> usize {
266 self.len()
267 }
268 #[inline]
269 fn last(mut self) -> Option<Self::Item> {
270 self.next_back()
271 }
272}
273impl<'a, T> DoubleEndedIterator for Tuple4Iter<'a, T> {
274 #[inline]
275 fn next_back(&mut self) -> Option<Self::Item> {
276 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
277 }
278}
279impl<'a, T> ExactSizeIterator for Tuple4Iter<'a, T> {
280 #[inline]
281 fn len(&self) -> usize {
282 self.1.end - self.1.start
283 }
284}
285impl<'a, T> FusedIterator for Tuple4Iter<'a, T> {}
286impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T) {
287 type Iter = Tuple4Iter<'a, T>;
288 #[inline]
289 fn iter(&'a self) -> Self::Iter {
290 Tuple4Iter::new(self)
291 }
292}
293#[derive(Debug)]
294pub struct Tuple4IntoIter<T>([MaybeUninit<T>; 4], Range<usize>);
295impl<T> Tuple4IntoIter<T> {
296 #[inline]
297 pub fn new(t: (T, T, T, T)) -> Self {
298 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3)], 0..4)
299 }
300}
301impl<T> Iterator for Tuple4IntoIter<T> {
302 type Item = T;
303 #[inline]
304 fn next(&mut self) -> Option<Self::Item> {
305 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
306 }
307 #[inline]
308 fn size_hint(&self) -> (usize, Option<usize>) {
309 let len = self.len();
310 (len, Some(len))
311 }
312 #[inline]
313 fn count(self) -> usize {
314 self.len()
315 }
316 #[inline]
317 fn last(mut self) -> Option<Self::Item> {
318 self.next_back()
319 }
320}
321impl<T> DoubleEndedIterator for Tuple4IntoIter<T> {
322 fn next_back(&mut self) -> Option<Self::Item> {
323 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
324 }
325}
326impl<T> ExactSizeIterator for Tuple4IntoIter<T> {
327 #[inline]
328 fn len(&self) -> usize {
329 self.1.end - self.1.start
330 }
331}
332impl<T> FusedIterator for Tuple4IntoIter<T> {}
333impl<T> TupleIntoIter for (T, T, T, T) {
334 type Iter = Tuple4IntoIter<T>;
335 #[inline]
336 fn into_iter(self) -> Self::Iter {
337 Tuple4IntoIter::new(self)
338 }
339}
340impl<T> Drop for Tuple4IntoIter<T> {
341 fn drop(&mut self) {
342 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
343 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
344 unsafe { core::ptr::drop_in_place(slice) }
345 }
346}
347impl<T> TupleFromIter<T> for (T, T, T, T) {
348 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
349 let mut iter = iter.into_iter();
350 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
351 }
352}
353impl<T> TupleTryFromIter<T> for (T, T, T, T) {
354 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
355 let mut iter = iter.into_iter();
356 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?))
357 }
358}
359impl<T> TupleFromIterTry<T> for (T, T, T, T) {
360 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>);
361 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
362 let mut iter = iter.into_iter();
363 (iter.next(), iter.next(), iter.next(), iter.next())
364 }
365}
366#[derive(Debug, Clone)]
367pub struct Tuple5Iter<'a, T>([&'a T; 5], Range<usize>);
368impl<'a, T> Tuple5Iter<'a, T> {
369 #[inline]
370 pub fn new(t: &'a (T, T, T, T, T)) -> Self {
371 Self([&t.0, &t.1, &t.2, &t.3, &t.4], 0..5)
372 }
373}
374impl<'a, T> Iterator for Tuple5Iter<'a, T> {
375 type Item = &'a T;
376 #[inline]
377 fn next(&mut self) -> Option<Self::Item> {
378 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
379 }
380 #[inline]
381 fn size_hint(&self) -> (usize, Option<usize>) {
382 let len = self.len();
383 (len, Some(len))
384 }
385 #[inline]
386 fn count(self) -> usize {
387 self.len()
388 }
389 #[inline]
390 fn last(mut self) -> Option<Self::Item> {
391 self.next_back()
392 }
393}
394impl<'a, T> DoubleEndedIterator for Tuple5Iter<'a, T> {
395 #[inline]
396 fn next_back(&mut self) -> Option<Self::Item> {
397 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
398 }
399}
400impl<'a, T> ExactSizeIterator for Tuple5Iter<'a, T> {
401 #[inline]
402 fn len(&self) -> usize {
403 self.1.end - self.1.start
404 }
405}
406impl<'a, T> FusedIterator for Tuple5Iter<'a, T> {}
407impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T) {
408 type Iter = Tuple5Iter<'a, T>;
409 #[inline]
410 fn iter(&'a self) -> Self::Iter {
411 Tuple5Iter::new(self)
412 }
413}
414#[derive(Debug)]
415pub struct Tuple5IntoIter<T>([MaybeUninit<T>; 5], Range<usize>);
416impl<T> Tuple5IntoIter<T> {
417 #[inline]
418 pub fn new(t: (T, T, T, T, T)) -> Self {
419 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4)], 0..5)
420 }
421}
422impl<T> Iterator for Tuple5IntoIter<T> {
423 type Item = T;
424 #[inline]
425 fn next(&mut self) -> Option<Self::Item> {
426 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
427 }
428 #[inline]
429 fn size_hint(&self) -> (usize, Option<usize>) {
430 let len = self.len();
431 (len, Some(len))
432 }
433 #[inline]
434 fn count(self) -> usize {
435 self.len()
436 }
437 #[inline]
438 fn last(mut self) -> Option<Self::Item> {
439 self.next_back()
440 }
441}
442impl<T> DoubleEndedIterator for Tuple5IntoIter<T> {
443 fn next_back(&mut self) -> Option<Self::Item> {
444 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
445 }
446}
447impl<T> ExactSizeIterator for Tuple5IntoIter<T> {
448 #[inline]
449 fn len(&self) -> usize {
450 self.1.end - self.1.start
451 }
452}
453impl<T> FusedIterator for Tuple5IntoIter<T> {}
454impl<T> TupleIntoIter for (T, T, T, T, T) {
455 type Iter = Tuple5IntoIter<T>;
456 #[inline]
457 fn into_iter(self) -> Self::Iter {
458 Tuple5IntoIter::new(self)
459 }
460}
461impl<T> Drop for Tuple5IntoIter<T> {
462 fn drop(&mut self) {
463 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
464 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
465 unsafe { core::ptr::drop_in_place(slice) }
466 }
467}
468impl<T> TupleFromIter<T> for (T, T, T, T, T) {
469 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
470 let mut iter = iter.into_iter();
471 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
472 }
473}
474impl<T> TupleTryFromIter<T> for (T, T, T, T, T) {
475 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
476 let mut iter = iter.into_iter();
477 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
478 }
479}
480impl<T> TupleFromIterTry<T> for (T, T, T, T, T) {
481 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
482 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
483 let mut iter = iter.into_iter();
484 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
485 }
486}
487#[derive(Debug, Clone)]
488pub struct Tuple6Iter<'a, T>([&'a T; 6], Range<usize>);
489impl<'a, T> Tuple6Iter<'a, T> {
490 #[inline]
491 pub fn new(t: &'a (T, T, T, T, T, T)) -> Self {
492 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5], 0..6)
493 }
494}
495impl<'a, T> Iterator for Tuple6Iter<'a, T> {
496 type Item = &'a T;
497 #[inline]
498 fn next(&mut self) -> Option<Self::Item> {
499 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
500 }
501 #[inline]
502 fn size_hint(&self) -> (usize, Option<usize>) {
503 let len = self.len();
504 (len, Some(len))
505 }
506 #[inline]
507 fn count(self) -> usize {
508 self.len()
509 }
510 #[inline]
511 fn last(mut self) -> Option<Self::Item> {
512 self.next_back()
513 }
514}
515impl<'a, T> DoubleEndedIterator for Tuple6Iter<'a, T> {
516 #[inline]
517 fn next_back(&mut self) -> Option<Self::Item> {
518 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
519 }
520}
521impl<'a, T> ExactSizeIterator for Tuple6Iter<'a, T> {
522 #[inline]
523 fn len(&self) -> usize {
524 self.1.end - self.1.start
525 }
526}
527impl<'a, T> FusedIterator for Tuple6Iter<'a, T> {}
528impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T) {
529 type Iter = Tuple6Iter<'a, T>;
530 #[inline]
531 fn iter(&'a self) -> Self::Iter {
532 Tuple6Iter::new(self)
533 }
534}
535#[derive(Debug)]
536pub struct Tuple6IntoIter<T>([MaybeUninit<T>; 6], Range<usize>);
537impl<T> Tuple6IntoIter<T> {
538 #[inline]
539 pub fn new(t: (T, T, T, T, T, T)) -> Self {
540 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5)], 0..6)
541 }
542}
543impl<T> Iterator for Tuple6IntoIter<T> {
544 type Item = T;
545 #[inline]
546 fn next(&mut self) -> Option<Self::Item> {
547 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
548 }
549 #[inline]
550 fn size_hint(&self) -> (usize, Option<usize>) {
551 let len = self.len();
552 (len, Some(len))
553 }
554 #[inline]
555 fn count(self) -> usize {
556 self.len()
557 }
558 #[inline]
559 fn last(mut self) -> Option<Self::Item> {
560 self.next_back()
561 }
562}
563impl<T> DoubleEndedIterator for Tuple6IntoIter<T> {
564 fn next_back(&mut self) -> Option<Self::Item> {
565 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
566 }
567}
568impl<T> ExactSizeIterator for Tuple6IntoIter<T> {
569 #[inline]
570 fn len(&self) -> usize {
571 self.1.end - self.1.start
572 }
573}
574impl<T> FusedIterator for Tuple6IntoIter<T> {}
575impl<T> TupleIntoIter for (T, T, T, T, T, T) {
576 type Iter = Tuple6IntoIter<T>;
577 #[inline]
578 fn into_iter(self) -> Self::Iter {
579 Tuple6IntoIter::new(self)
580 }
581}
582impl<T> Drop for Tuple6IntoIter<T> {
583 fn drop(&mut self) {
584 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
585 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
586 unsafe { core::ptr::drop_in_place(slice) }
587 }
588}
589impl<T> TupleFromIter<T> for (T, T, T, T, T, T) {
590 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
591 let mut iter = iter.into_iter();
592 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
593 }
594}
595impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T) {
596 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
597 let mut iter = iter.into_iter();
598 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
599 }
600}
601impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T) {
602 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
603 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
604 let mut iter = iter.into_iter();
605 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
606 }
607}
608#[derive(Debug, Clone)]
609pub struct Tuple7Iter<'a, T>([&'a T; 7], Range<usize>);
610impl<'a, T> Tuple7Iter<'a, T> {
611 #[inline]
612 pub fn new(t: &'a (T, T, T, T, T, T, T)) -> Self {
613 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6], 0..7)
614 }
615}
616impl<'a, T> Iterator for Tuple7Iter<'a, T> {
617 type Item = &'a T;
618 #[inline]
619 fn next(&mut self) -> Option<Self::Item> {
620 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
621 }
622 #[inline]
623 fn size_hint(&self) -> (usize, Option<usize>) {
624 let len = self.len();
625 (len, Some(len))
626 }
627 #[inline]
628 fn count(self) -> usize {
629 self.len()
630 }
631 #[inline]
632 fn last(mut self) -> Option<Self::Item> {
633 self.next_back()
634 }
635}
636impl<'a, T> DoubleEndedIterator for Tuple7Iter<'a, T> {
637 #[inline]
638 fn next_back(&mut self) -> Option<Self::Item> {
639 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
640 }
641}
642impl<'a, T> ExactSizeIterator for Tuple7Iter<'a, T> {
643 #[inline]
644 fn len(&self) -> usize {
645 self.1.end - self.1.start
646 }
647}
648impl<'a, T> FusedIterator for Tuple7Iter<'a, T> {}
649impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T) {
650 type Iter = Tuple7Iter<'a, T>;
651 #[inline]
652 fn iter(&'a self) -> Self::Iter {
653 Tuple7Iter::new(self)
654 }
655}
656#[derive(Debug)]
657pub struct Tuple7IntoIter<T>([MaybeUninit<T>; 7], Range<usize>);
658impl<T> Tuple7IntoIter<T> {
659 #[inline]
660 pub fn new(t: (T, T, T, T, T, T, T)) -> Self {
661 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6)], 0..7)
662 }
663}
664impl<T> Iterator for Tuple7IntoIter<T> {
665 type Item = T;
666 #[inline]
667 fn next(&mut self) -> Option<Self::Item> {
668 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
669 }
670 #[inline]
671 fn size_hint(&self) -> (usize, Option<usize>) {
672 let len = self.len();
673 (len, Some(len))
674 }
675 #[inline]
676 fn count(self) -> usize {
677 self.len()
678 }
679 #[inline]
680 fn last(mut self) -> Option<Self::Item> {
681 self.next_back()
682 }
683}
684impl<T> DoubleEndedIterator for Tuple7IntoIter<T> {
685 fn next_back(&mut self) -> Option<Self::Item> {
686 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
687 }
688}
689impl<T> ExactSizeIterator for Tuple7IntoIter<T> {
690 #[inline]
691 fn len(&self) -> usize {
692 self.1.end - self.1.start
693 }
694}
695impl<T> FusedIterator for Tuple7IntoIter<T> {}
696impl<T> TupleIntoIter for (T, T, T, T, T, T, T) {
697 type Iter = Tuple7IntoIter<T>;
698 #[inline]
699 fn into_iter(self) -> Self::Iter {
700 Tuple7IntoIter::new(self)
701 }
702}
703impl<T> Drop for Tuple7IntoIter<T> {
704 fn drop(&mut self) {
705 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
706 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
707 unsafe { core::ptr::drop_in_place(slice) }
708 }
709}
710impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T) {
711 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
712 let mut iter = iter.into_iter();
713 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
714 }
715}
716impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T) {
717 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
718 let mut iter = iter.into_iter();
719 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
720 }
721}
722impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T) {
723 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
724 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
725 let mut iter = iter.into_iter();
726 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
727 }
728}
729#[derive(Debug, Clone)]
730pub struct Tuple8Iter<'a, T>([&'a T; 8], Range<usize>);
731impl<'a, T> Tuple8Iter<'a, T> {
732 #[inline]
733 pub fn new(t: &'a (T, T, T, T, T, T, T, T)) -> Self {
734 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7], 0..8)
735 }
736}
737impl<'a, T> Iterator for Tuple8Iter<'a, T> {
738 type Item = &'a T;
739 #[inline]
740 fn next(&mut self) -> Option<Self::Item> {
741 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
742 }
743 #[inline]
744 fn size_hint(&self) -> (usize, Option<usize>) {
745 let len = self.len();
746 (len, Some(len))
747 }
748 #[inline]
749 fn count(self) -> usize {
750 self.len()
751 }
752 #[inline]
753 fn last(mut self) -> Option<Self::Item> {
754 self.next_back()
755 }
756}
757impl<'a, T> DoubleEndedIterator for Tuple8Iter<'a, T> {
758 #[inline]
759 fn next_back(&mut self) -> Option<Self::Item> {
760 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
761 }
762}
763impl<'a, T> ExactSizeIterator for Tuple8Iter<'a, T> {
764 #[inline]
765 fn len(&self) -> usize {
766 self.1.end - self.1.start
767 }
768}
769impl<'a, T> FusedIterator for Tuple8Iter<'a, T> {}
770impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T) {
771 type Iter = Tuple8Iter<'a, T>;
772 #[inline]
773 fn iter(&'a self) -> Self::Iter {
774 Tuple8Iter::new(self)
775 }
776}
777#[derive(Debug)]
778pub struct Tuple8IntoIter<T>([MaybeUninit<T>; 8], Range<usize>);
779impl<T> Tuple8IntoIter<T> {
780 #[inline]
781 pub fn new(t: (T, T, T, T, T, T, T, T)) -> Self {
782 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7)], 0..8)
783 }
784}
785impl<T> Iterator for Tuple8IntoIter<T> {
786 type Item = T;
787 #[inline]
788 fn next(&mut self) -> Option<Self::Item> {
789 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
790 }
791 #[inline]
792 fn size_hint(&self) -> (usize, Option<usize>) {
793 let len = self.len();
794 (len, Some(len))
795 }
796 #[inline]
797 fn count(self) -> usize {
798 self.len()
799 }
800 #[inline]
801 fn last(mut self) -> Option<Self::Item> {
802 self.next_back()
803 }
804}
805impl<T> DoubleEndedIterator for Tuple8IntoIter<T> {
806 fn next_back(&mut self) -> Option<Self::Item> {
807 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
808 }
809}
810impl<T> ExactSizeIterator for Tuple8IntoIter<T> {
811 #[inline]
812 fn len(&self) -> usize {
813 self.1.end - self.1.start
814 }
815}
816impl<T> FusedIterator for Tuple8IntoIter<T> {}
817impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T) {
818 type Iter = Tuple8IntoIter<T>;
819 #[inline]
820 fn into_iter(self) -> Self::Iter {
821 Tuple8IntoIter::new(self)
822 }
823}
824impl<T> Drop for Tuple8IntoIter<T> {
825 fn drop(&mut self) {
826 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
827 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
828 unsafe { core::ptr::drop_in_place(slice) }
829 }
830}
831impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T) {
832 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
833 let mut iter = iter.into_iter();
834 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
835 }
836}
837impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T) {
838 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
839 let mut iter = iter.into_iter();
840 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
841 }
842}
843impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T) {
844 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
845 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
846 let mut iter = iter.into_iter();
847 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
848 }
849}
850#[derive(Debug, Clone)]
851pub struct Tuple9Iter<'a, T>([&'a T; 9], Range<usize>);
852impl<'a, T> Tuple9Iter<'a, T> {
853 #[inline]
854 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T)) -> Self {
855 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8], 0..9)
856 }
857}
858impl<'a, T> Iterator for Tuple9Iter<'a, T> {
859 type Item = &'a T;
860 #[inline]
861 fn next(&mut self) -> Option<Self::Item> {
862 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
863 }
864 #[inline]
865 fn size_hint(&self) -> (usize, Option<usize>) {
866 let len = self.len();
867 (len, Some(len))
868 }
869 #[inline]
870 fn count(self) -> usize {
871 self.len()
872 }
873 #[inline]
874 fn last(mut self) -> Option<Self::Item> {
875 self.next_back()
876 }
877}
878impl<'a, T> DoubleEndedIterator for Tuple9Iter<'a, T> {
879 #[inline]
880 fn next_back(&mut self) -> Option<Self::Item> {
881 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
882 }
883}
884impl<'a, T> ExactSizeIterator for Tuple9Iter<'a, T> {
885 #[inline]
886 fn len(&self) -> usize {
887 self.1.end - self.1.start
888 }
889}
890impl<'a, T> FusedIterator for Tuple9Iter<'a, T> {}
891impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T) {
892 type Iter = Tuple9Iter<'a, T>;
893 #[inline]
894 fn iter(&'a self) -> Self::Iter {
895 Tuple9Iter::new(self)
896 }
897}
898#[derive(Debug)]
899pub struct Tuple9IntoIter<T>([MaybeUninit<T>; 9], Range<usize>);
900impl<T> Tuple9IntoIter<T> {
901 #[inline]
902 pub fn new(t: (T, T, T, T, T, T, T, T, T)) -> Self {
903 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8)], 0..9)
904 }
905}
906impl<T> Iterator for Tuple9IntoIter<T> {
907 type Item = T;
908 #[inline]
909 fn next(&mut self) -> Option<Self::Item> {
910 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
911 }
912 #[inline]
913 fn size_hint(&self) -> (usize, Option<usize>) {
914 let len = self.len();
915 (len, Some(len))
916 }
917 #[inline]
918 fn count(self) -> usize {
919 self.len()
920 }
921 #[inline]
922 fn last(mut self) -> Option<Self::Item> {
923 self.next_back()
924 }
925}
926impl<T> DoubleEndedIterator for Tuple9IntoIter<T> {
927 fn next_back(&mut self) -> Option<Self::Item> {
928 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
929 }
930}
931impl<T> ExactSizeIterator for Tuple9IntoIter<T> {
932 #[inline]
933 fn len(&self) -> usize {
934 self.1.end - self.1.start
935 }
936}
937impl<T> FusedIterator for Tuple9IntoIter<T> {}
938impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T) {
939 type Iter = Tuple9IntoIter<T>;
940 #[inline]
941 fn into_iter(self) -> Self::Iter {
942 Tuple9IntoIter::new(self)
943 }
944}
945impl<T> Drop for Tuple9IntoIter<T> {
946 fn drop(&mut self) {
947 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
948 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
949 unsafe { core::ptr::drop_in_place(slice) }
950 }
951}
952impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T) {
953 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
954 let mut iter = iter.into_iter();
955 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
956 }
957}
958impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T) {
959 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
960 let mut iter = iter.into_iter();
961 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
962 }
963}
964impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T) {
965 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
966 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
967 let mut iter = iter.into_iter();
968 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
969 }
970}
971#[derive(Debug, Clone)]
972pub struct Tuple10Iter<'a, T>([&'a T; 10], Range<usize>);
973impl<'a, T> Tuple10Iter<'a, T> {
974 #[inline]
975 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T)) -> Self {
976 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9], 0..10)
977 }
978}
979impl<'a, T> Iterator for Tuple10Iter<'a, T> {
980 type Item = &'a T;
981 #[inline]
982 fn next(&mut self) -> Option<Self::Item> {
983 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
984 }
985 #[inline]
986 fn size_hint(&self) -> (usize, Option<usize>) {
987 let len = self.len();
988 (len, Some(len))
989 }
990 #[inline]
991 fn count(self) -> usize {
992 self.len()
993 }
994 #[inline]
995 fn last(mut self) -> Option<Self::Item> {
996 self.next_back()
997 }
998}
999impl<'a, T> DoubleEndedIterator for Tuple10Iter<'a, T> {
1000 #[inline]
1001 fn next_back(&mut self) -> Option<Self::Item> {
1002 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1003 }
1004}
1005impl<'a, T> ExactSizeIterator for Tuple10Iter<'a, T> {
1006 #[inline]
1007 fn len(&self) -> usize {
1008 self.1.end - self.1.start
1009 }
1010}
1011impl<'a, T> FusedIterator for Tuple10Iter<'a, T> {}
1012impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T) {
1013 type Iter = Tuple10Iter<'a, T>;
1014 #[inline]
1015 fn iter(&'a self) -> Self::Iter {
1016 Tuple10Iter::new(self)
1017 }
1018}
1019#[derive(Debug)]
1020pub struct Tuple10IntoIter<T>([MaybeUninit<T>; 10], Range<usize>);
1021impl<T> Tuple10IntoIter<T> {
1022 #[inline]
1023 pub fn new(t: (T, T, T, T, T, T, T, T, T, T)) -> Self {
1024 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9)], 0..10)
1025 }
1026}
1027impl<T> Iterator for Tuple10IntoIter<T> {
1028 type Item = T;
1029 #[inline]
1030 fn next(&mut self) -> Option<Self::Item> {
1031 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1032 }
1033 #[inline]
1034 fn size_hint(&self) -> (usize, Option<usize>) {
1035 let len = self.len();
1036 (len, Some(len))
1037 }
1038 #[inline]
1039 fn count(self) -> usize {
1040 self.len()
1041 }
1042 #[inline]
1043 fn last(mut self) -> Option<Self::Item> {
1044 self.next_back()
1045 }
1046}
1047impl<T> DoubleEndedIterator for Tuple10IntoIter<T> {
1048 fn next_back(&mut self) -> Option<Self::Item> {
1049 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1050 }
1051}
1052impl<T> ExactSizeIterator for Tuple10IntoIter<T> {
1053 #[inline]
1054 fn len(&self) -> usize {
1055 self.1.end - self.1.start
1056 }
1057}
1058impl<T> FusedIterator for Tuple10IntoIter<T> {}
1059impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T) {
1060 type Iter = Tuple10IntoIter<T>;
1061 #[inline]
1062 fn into_iter(self) -> Self::Iter {
1063 Tuple10IntoIter::new(self)
1064 }
1065}
1066impl<T> Drop for Tuple10IntoIter<T> {
1067 fn drop(&mut self) {
1068 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
1069 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
1070 unsafe { core::ptr::drop_in_place(slice) }
1071 }
1072}
1073impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T) {
1074 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
1075 let mut iter = iter.into_iter();
1076 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
1077 }
1078}
1079impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T) {
1080 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
1081 let mut iter = iter.into_iter();
1082 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
1083 }
1084}
1085impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T) {
1086 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
1087 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
1088 let mut iter = iter.into_iter();
1089 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
1090 }
1091}
1092#[derive(Debug, Clone)]
1093pub struct Tuple11Iter<'a, T>([&'a T; 11], Range<usize>);
1094impl<'a, T> Tuple11Iter<'a, T> {
1095 #[inline]
1096 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1097 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10], 0..11)
1098 }
1099}
1100impl<'a, T> Iterator for Tuple11Iter<'a, T> {
1101 type Item = &'a T;
1102 #[inline]
1103 fn next(&mut self) -> Option<Self::Item> {
1104 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1105 }
1106 #[inline]
1107 fn size_hint(&self) -> (usize, Option<usize>) {
1108 let len = self.len();
1109 (len, Some(len))
1110 }
1111 #[inline]
1112 fn count(self) -> usize {
1113 self.len()
1114 }
1115 #[inline]
1116 fn last(mut self) -> Option<Self::Item> {
1117 self.next_back()
1118 }
1119}
1120impl<'a, T> DoubleEndedIterator for Tuple11Iter<'a, T> {
1121 #[inline]
1122 fn next_back(&mut self) -> Option<Self::Item> {
1123 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1124 }
1125}
1126impl<'a, T> ExactSizeIterator for Tuple11Iter<'a, T> {
1127 #[inline]
1128 fn len(&self) -> usize {
1129 self.1.end - self.1.start
1130 }
1131}
1132impl<'a, T> FusedIterator for Tuple11Iter<'a, T> {}
1133impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T) {
1134 type Iter = Tuple11Iter<'a, T>;
1135 #[inline]
1136 fn iter(&'a self) -> Self::Iter {
1137 Tuple11Iter::new(self)
1138 }
1139}
1140#[derive(Debug)]
1141pub struct Tuple11IntoIter<T>([MaybeUninit<T>; 11], Range<usize>);
1142impl<T> Tuple11IntoIter<T> {
1143 #[inline]
1144 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1145 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10)], 0..11)
1146 }
1147}
1148impl<T> Iterator for Tuple11IntoIter<T> {
1149 type Item = T;
1150 #[inline]
1151 fn next(&mut self) -> Option<Self::Item> {
1152 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1153 }
1154 #[inline]
1155 fn size_hint(&self) -> (usize, Option<usize>) {
1156 let len = self.len();
1157 (len, Some(len))
1158 }
1159 #[inline]
1160 fn count(self) -> usize {
1161 self.len()
1162 }
1163 #[inline]
1164 fn last(mut self) -> Option<Self::Item> {
1165 self.next_back()
1166 }
1167}
1168impl<T> DoubleEndedIterator for Tuple11IntoIter<T> {
1169 fn next_back(&mut self) -> Option<Self::Item> {
1170 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1171 }
1172}
1173impl<T> ExactSizeIterator for Tuple11IntoIter<T> {
1174 #[inline]
1175 fn len(&self) -> usize {
1176 self.1.end - self.1.start
1177 }
1178}
1179impl<T> FusedIterator for Tuple11IntoIter<T> {}
1180impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T) {
1181 type Iter = Tuple11IntoIter<T>;
1182 #[inline]
1183 fn into_iter(self) -> Self::Iter {
1184 Tuple11IntoIter::new(self)
1185 }
1186}
1187impl<T> Drop for Tuple11IntoIter<T> {
1188 fn drop(&mut self) {
1189 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
1190 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
1191 unsafe { core::ptr::drop_in_place(slice) }
1192 }
1193}
1194impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T) {
1195 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
1196 let mut iter = iter.into_iter();
1197 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
1198 }
1199}
1200impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T) {
1201 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
1202 let mut iter = iter.into_iter();
1203 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
1204 }
1205}
1206impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T) {
1207 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
1208 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
1209 let mut iter = iter.into_iter();
1210 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
1211 }
1212}
1213#[derive(Debug, Clone)]
1214pub struct Tuple12Iter<'a, T>([&'a T; 12], Range<usize>);
1215impl<'a, T> Tuple12Iter<'a, T> {
1216 #[inline]
1217 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1218 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11], 0..12)
1219 }
1220}
1221impl<'a, T> Iterator for Tuple12Iter<'a, T> {
1222 type Item = &'a T;
1223 #[inline]
1224 fn next(&mut self) -> Option<Self::Item> {
1225 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1226 }
1227 #[inline]
1228 fn size_hint(&self) -> (usize, Option<usize>) {
1229 let len = self.len();
1230 (len, Some(len))
1231 }
1232 #[inline]
1233 fn count(self) -> usize {
1234 self.len()
1235 }
1236 #[inline]
1237 fn last(mut self) -> Option<Self::Item> {
1238 self.next_back()
1239 }
1240}
1241impl<'a, T> DoubleEndedIterator for Tuple12Iter<'a, T> {
1242 #[inline]
1243 fn next_back(&mut self) -> Option<Self::Item> {
1244 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1245 }
1246}
1247impl<'a, T> ExactSizeIterator for Tuple12Iter<'a, T> {
1248 #[inline]
1249 fn len(&self) -> usize {
1250 self.1.end - self.1.start
1251 }
1252}
1253impl<'a, T> FusedIterator for Tuple12Iter<'a, T> {}
1254impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T) {
1255 type Iter = Tuple12Iter<'a, T>;
1256 #[inline]
1257 fn iter(&'a self) -> Self::Iter {
1258 Tuple12Iter::new(self)
1259 }
1260}
1261#[derive(Debug)]
1262pub struct Tuple12IntoIter<T>([MaybeUninit<T>; 12], Range<usize>);
1263impl<T> Tuple12IntoIter<T> {
1264 #[inline]
1265 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1266 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11)], 0..12)
1267 }
1268}
1269impl<T> Iterator for Tuple12IntoIter<T> {
1270 type Item = T;
1271 #[inline]
1272 fn next(&mut self) -> Option<Self::Item> {
1273 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1274 }
1275 #[inline]
1276 fn size_hint(&self) -> (usize, Option<usize>) {
1277 let len = self.len();
1278 (len, Some(len))
1279 }
1280 #[inline]
1281 fn count(self) -> usize {
1282 self.len()
1283 }
1284 #[inline]
1285 fn last(mut self) -> Option<Self::Item> {
1286 self.next_back()
1287 }
1288}
1289impl<T> DoubleEndedIterator for Tuple12IntoIter<T> {
1290 fn next_back(&mut self) -> Option<Self::Item> {
1291 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1292 }
1293}
1294impl<T> ExactSizeIterator for Tuple12IntoIter<T> {
1295 #[inline]
1296 fn len(&self) -> usize {
1297 self.1.end - self.1.start
1298 }
1299}
1300impl<T> FusedIterator for Tuple12IntoIter<T> {}
1301impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T) {
1302 type Iter = Tuple12IntoIter<T>;
1303 #[inline]
1304 fn into_iter(self) -> Self::Iter {
1305 Tuple12IntoIter::new(self)
1306 }
1307}
1308impl<T> Drop for Tuple12IntoIter<T> {
1309 fn drop(&mut self) {
1310 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
1311 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
1312 unsafe { core::ptr::drop_in_place(slice) }
1313 }
1314}
1315impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T) {
1316 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
1317 let mut iter = iter.into_iter();
1318 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
1319 }
1320}
1321impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T) {
1322 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
1323 let mut iter = iter.into_iter();
1324 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
1325 }
1326}
1327impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T) {
1328 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
1329 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
1330 let mut iter = iter.into_iter();
1331 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
1332 }
1333}
1334pub struct Tuple13Iter<'a, T>([&'a T; 13], Range<usize>);
1335impl<'a, T> Tuple13Iter<'a, T> {
1336 #[inline]
1337 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1338 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12], 0..13)
1339 }
1340}
1341impl<'a, T> Iterator for Tuple13Iter<'a, T> {
1342 type Item = &'a T;
1343 #[inline]
1344 fn next(&mut self) -> Option<Self::Item> {
1345 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1346 }
1347 #[inline]
1348 fn size_hint(&self) -> (usize, Option<usize>) {
1349 let len = self.len();
1350 (len, Some(len))
1351 }
1352 #[inline]
1353 fn count(self) -> usize {
1354 self.len()
1355 }
1356 #[inline]
1357 fn last(mut self) -> Option<Self::Item> {
1358 self.next_back()
1359 }
1360}
1361impl<'a, T> DoubleEndedIterator for Tuple13Iter<'a, T> {
1362 #[inline]
1363 fn next_back(&mut self) -> Option<Self::Item> {
1364 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1365 }
1366}
1367impl<'a, T> ExactSizeIterator for Tuple13Iter<'a, T> {
1368 #[inline]
1369 fn len(&self) -> usize {
1370 self.1.end - self.1.start
1371 }
1372}
1373impl<'a, T> FusedIterator for Tuple13Iter<'a, T> {}
1374impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T) {
1375 type Iter = Tuple13Iter<'a, T>;
1376 #[inline]
1377 fn iter(&'a self) -> Self::Iter {
1378 Tuple13Iter::new(self)
1379 }
1380}
1381pub struct Tuple13IntoIter<T>([MaybeUninit<T>; 13], Range<usize>);
1382impl<T> Tuple13IntoIter<T> {
1383 #[inline]
1384 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1385 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12)], 0..13)
1386 }
1387}
1388impl<T> Iterator for Tuple13IntoIter<T> {
1389 type Item = T;
1390 #[inline]
1391 fn next(&mut self) -> Option<Self::Item> {
1392 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1393 }
1394 #[inline]
1395 fn size_hint(&self) -> (usize, Option<usize>) {
1396 let len = self.len();
1397 (len, Some(len))
1398 }
1399 #[inline]
1400 fn count(self) -> usize {
1401 self.len()
1402 }
1403 #[inline]
1404 fn last(mut self) -> Option<Self::Item> {
1405 self.next_back()
1406 }
1407}
1408impl<T> DoubleEndedIterator for Tuple13IntoIter<T> {
1409 fn next_back(&mut self) -> Option<Self::Item> {
1410 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1411 }
1412}
1413impl<T> ExactSizeIterator for Tuple13IntoIter<T> {
1414 #[inline]
1415 fn len(&self) -> usize {
1416 self.1.end - self.1.start
1417 }
1418}
1419impl<T> FusedIterator for Tuple13IntoIter<T> {}
1420impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T) {
1421 type Iter = Tuple13IntoIter<T>;
1422 #[inline]
1423 fn into_iter(self) -> Self::Iter {
1424 Tuple13IntoIter::new(self)
1425 }
1426}
1427impl<T> Drop for Tuple13IntoIter<T> {
1428 fn drop(&mut self) {
1429 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
1430 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
1431 unsafe { core::ptr::drop_in_place(slice) }
1432 }
1433}
1434impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T) {
1435 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
1436 let mut iter = iter.into_iter();
1437 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
1438 }
1439}
1440impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T) {
1441 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
1442 let mut iter = iter.into_iter();
1443 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
1444 }
1445}
1446impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T) {
1447 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
1448 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
1449 let mut iter = iter.into_iter();
1450 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
1451 }
1452}
1453pub struct Tuple14Iter<'a, T>([&'a T; 14], Range<usize>);
1454impl<'a, T> Tuple14Iter<'a, T> {
1455 #[inline]
1456 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1457 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13], 0..14)
1458 }
1459}
1460impl<'a, T> Iterator for Tuple14Iter<'a, T> {
1461 type Item = &'a T;
1462 #[inline]
1463 fn next(&mut self) -> Option<Self::Item> {
1464 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1465 }
1466 #[inline]
1467 fn size_hint(&self) -> (usize, Option<usize>) {
1468 let len = self.len();
1469 (len, Some(len))
1470 }
1471 #[inline]
1472 fn count(self) -> usize {
1473 self.len()
1474 }
1475 #[inline]
1476 fn last(mut self) -> Option<Self::Item> {
1477 self.next_back()
1478 }
1479}
1480impl<'a, T> DoubleEndedIterator for Tuple14Iter<'a, T> {
1481 #[inline]
1482 fn next_back(&mut self) -> Option<Self::Item> {
1483 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1484 }
1485}
1486impl<'a, T> ExactSizeIterator for Tuple14Iter<'a, T> {
1487 #[inline]
1488 fn len(&self) -> usize {
1489 self.1.end - self.1.start
1490 }
1491}
1492impl<'a, T> FusedIterator for Tuple14Iter<'a, T> {}
1493impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1494 type Iter = Tuple14Iter<'a, T>;
1495 #[inline]
1496 fn iter(&'a self) -> Self::Iter {
1497 Tuple14Iter::new(self)
1498 }
1499}
1500pub struct Tuple14IntoIter<T>([MaybeUninit<T>; 14], Range<usize>);
1501impl<T> Tuple14IntoIter<T> {
1502 #[inline]
1503 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1504 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13)], 0..14)
1505 }
1506}
1507impl<T> Iterator for Tuple14IntoIter<T> {
1508 type Item = T;
1509 #[inline]
1510 fn next(&mut self) -> Option<Self::Item> {
1511 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1512 }
1513 #[inline]
1514 fn size_hint(&self) -> (usize, Option<usize>) {
1515 let len = self.len();
1516 (len, Some(len))
1517 }
1518 #[inline]
1519 fn count(self) -> usize {
1520 self.len()
1521 }
1522 #[inline]
1523 fn last(mut self) -> Option<Self::Item> {
1524 self.next_back()
1525 }
1526}
1527impl<T> DoubleEndedIterator for Tuple14IntoIter<T> {
1528 fn next_back(&mut self) -> Option<Self::Item> {
1529 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1530 }
1531}
1532impl<T> ExactSizeIterator for Tuple14IntoIter<T> {
1533 #[inline]
1534 fn len(&self) -> usize {
1535 self.1.end - self.1.start
1536 }
1537}
1538impl<T> FusedIterator for Tuple14IntoIter<T> {}
1539impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1540 type Iter = Tuple14IntoIter<T>;
1541 #[inline]
1542 fn into_iter(self) -> Self::Iter {
1543 Tuple14IntoIter::new(self)
1544 }
1545}
1546impl<T> Drop for Tuple14IntoIter<T> {
1547 fn drop(&mut self) {
1548 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
1549 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
1550 unsafe { core::ptr::drop_in_place(slice) }
1551 }
1552}
1553impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1554 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
1555 let mut iter = iter.into_iter();
1556 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
1557 }
1558}
1559impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1560 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
1561 let mut iter = iter.into_iter();
1562 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
1563 }
1564}
1565impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1566 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
1567 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
1568 let mut iter = iter.into_iter();
1569 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
1570 }
1571}
1572pub struct Tuple15Iter<'a, T>([&'a T; 15], Range<usize>);
1573impl<'a, T> Tuple15Iter<'a, T> {
1574 #[inline]
1575 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1576 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14], 0..15)
1577 }
1578}
1579impl<'a, T> Iterator for Tuple15Iter<'a, T> {
1580 type Item = &'a T;
1581 #[inline]
1582 fn next(&mut self) -> Option<Self::Item> {
1583 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1584 }
1585 #[inline]
1586 fn size_hint(&self) -> (usize, Option<usize>) {
1587 let len = self.len();
1588 (len, Some(len))
1589 }
1590 #[inline]
1591 fn count(self) -> usize {
1592 self.len()
1593 }
1594 #[inline]
1595 fn last(mut self) -> Option<Self::Item> {
1596 self.next_back()
1597 }
1598}
1599impl<'a, T> DoubleEndedIterator for Tuple15Iter<'a, T> {
1600 #[inline]
1601 fn next_back(&mut self) -> Option<Self::Item> {
1602 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1603 }
1604}
1605impl<'a, T> ExactSizeIterator for Tuple15Iter<'a, T> {
1606 #[inline]
1607 fn len(&self) -> usize {
1608 self.1.end - self.1.start
1609 }
1610}
1611impl<'a, T> FusedIterator for Tuple15Iter<'a, T> {}
1612impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1613 type Iter = Tuple15Iter<'a, T>;
1614 #[inline]
1615 fn iter(&'a self) -> Self::Iter {
1616 Tuple15Iter::new(self)
1617 }
1618}
1619pub struct Tuple15IntoIter<T>([MaybeUninit<T>; 15], Range<usize>);
1620impl<T> Tuple15IntoIter<T> {
1621 #[inline]
1622 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1623 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14)], 0..15)
1624 }
1625}
1626impl<T> Iterator for Tuple15IntoIter<T> {
1627 type Item = T;
1628 #[inline]
1629 fn next(&mut self) -> Option<Self::Item> {
1630 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1631 }
1632 #[inline]
1633 fn size_hint(&self) -> (usize, Option<usize>) {
1634 let len = self.len();
1635 (len, Some(len))
1636 }
1637 #[inline]
1638 fn count(self) -> usize {
1639 self.len()
1640 }
1641 #[inline]
1642 fn last(mut self) -> Option<Self::Item> {
1643 self.next_back()
1644 }
1645}
1646impl<T> DoubleEndedIterator for Tuple15IntoIter<T> {
1647 fn next_back(&mut self) -> Option<Self::Item> {
1648 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1649 }
1650}
1651impl<T> ExactSizeIterator for Tuple15IntoIter<T> {
1652 #[inline]
1653 fn len(&self) -> usize {
1654 self.1.end - self.1.start
1655 }
1656}
1657impl<T> FusedIterator for Tuple15IntoIter<T> {}
1658impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1659 type Iter = Tuple15IntoIter<T>;
1660 #[inline]
1661 fn into_iter(self) -> Self::Iter {
1662 Tuple15IntoIter::new(self)
1663 }
1664}
1665impl<T> Drop for Tuple15IntoIter<T> {
1666 fn drop(&mut self) {
1667 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
1668 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
1669 unsafe { core::ptr::drop_in_place(slice) }
1670 }
1671}
1672impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1673 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
1674 let mut iter = iter.into_iter();
1675 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
1676 }
1677}
1678impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1679 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
1680 let mut iter = iter.into_iter();
1681 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
1682 }
1683}
1684impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1685 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
1686 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
1687 let mut iter = iter.into_iter();
1688 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
1689 }
1690}
1691pub struct Tuple16Iter<'a, T>([&'a T; 16], Range<usize>);
1692impl<'a, T> Tuple16Iter<'a, T> {
1693 #[inline]
1694 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1695 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15], 0..16)
1696 }
1697}
1698impl<'a, T> Iterator for Tuple16Iter<'a, T> {
1699 type Item = &'a T;
1700 #[inline]
1701 fn next(&mut self) -> Option<Self::Item> {
1702 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1703 }
1704 #[inline]
1705 fn size_hint(&self) -> (usize, Option<usize>) {
1706 let len = self.len();
1707 (len, Some(len))
1708 }
1709 #[inline]
1710 fn count(self) -> usize {
1711 self.len()
1712 }
1713 #[inline]
1714 fn last(mut self) -> Option<Self::Item> {
1715 self.next_back()
1716 }
1717}
1718impl<'a, T> DoubleEndedIterator for Tuple16Iter<'a, T> {
1719 #[inline]
1720 fn next_back(&mut self) -> Option<Self::Item> {
1721 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1722 }
1723}
1724impl<'a, T> ExactSizeIterator for Tuple16Iter<'a, T> {
1725 #[inline]
1726 fn len(&self) -> usize {
1727 self.1.end - self.1.start
1728 }
1729}
1730impl<'a, T> FusedIterator for Tuple16Iter<'a, T> {}
1731impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1732 type Iter = Tuple16Iter<'a, T>;
1733 #[inline]
1734 fn iter(&'a self) -> Self::Iter {
1735 Tuple16Iter::new(self)
1736 }
1737}
1738pub struct Tuple16IntoIter<T>([MaybeUninit<T>; 16], Range<usize>);
1739impl<T> Tuple16IntoIter<T> {
1740 #[inline]
1741 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1742 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15)], 0..16)
1743 }
1744}
1745impl<T> Iterator for Tuple16IntoIter<T> {
1746 type Item = T;
1747 #[inline]
1748 fn next(&mut self) -> Option<Self::Item> {
1749 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1750 }
1751 #[inline]
1752 fn size_hint(&self) -> (usize, Option<usize>) {
1753 let len = self.len();
1754 (len, Some(len))
1755 }
1756 #[inline]
1757 fn count(self) -> usize {
1758 self.len()
1759 }
1760 #[inline]
1761 fn last(mut self) -> Option<Self::Item> {
1762 self.next_back()
1763 }
1764}
1765impl<T> DoubleEndedIterator for Tuple16IntoIter<T> {
1766 fn next_back(&mut self) -> Option<Self::Item> {
1767 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1768 }
1769}
1770impl<T> ExactSizeIterator for Tuple16IntoIter<T> {
1771 #[inline]
1772 fn len(&self) -> usize {
1773 self.1.end - self.1.start
1774 }
1775}
1776impl<T> FusedIterator for Tuple16IntoIter<T> {}
1777impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1778 type Iter = Tuple16IntoIter<T>;
1779 #[inline]
1780 fn into_iter(self) -> Self::Iter {
1781 Tuple16IntoIter::new(self)
1782 }
1783}
1784impl<T> Drop for Tuple16IntoIter<T> {
1785 fn drop(&mut self) {
1786 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
1787 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
1788 unsafe { core::ptr::drop_in_place(slice) }
1789 }
1790}
1791impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1792 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
1793 let mut iter = iter.into_iter();
1794 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
1795 }
1796}
1797impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1798 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
1799 let mut iter = iter.into_iter();
1800 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
1801 }
1802}
1803impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1804 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
1805 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
1806 let mut iter = iter.into_iter();
1807 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
1808 }
1809}
1810pub struct Tuple17Iter<'a, T>([&'a T; 17], Range<usize>);
1811impl<'a, T> Tuple17Iter<'a, T> {
1812 #[inline]
1813 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1814 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16], 0..17)
1815 }
1816}
1817impl<'a, T> Iterator for Tuple17Iter<'a, T> {
1818 type Item = &'a T;
1819 #[inline]
1820 fn next(&mut self) -> Option<Self::Item> {
1821 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1822 }
1823 #[inline]
1824 fn size_hint(&self) -> (usize, Option<usize>) {
1825 let len = self.len();
1826 (len, Some(len))
1827 }
1828 #[inline]
1829 fn count(self) -> usize {
1830 self.len()
1831 }
1832 #[inline]
1833 fn last(mut self) -> Option<Self::Item> {
1834 self.next_back()
1835 }
1836}
1837impl<'a, T> DoubleEndedIterator for Tuple17Iter<'a, T> {
1838 #[inline]
1839 fn next_back(&mut self) -> Option<Self::Item> {
1840 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1841 }
1842}
1843impl<'a, T> ExactSizeIterator for Tuple17Iter<'a, T> {
1844 #[inline]
1845 fn len(&self) -> usize {
1846 self.1.end - self.1.start
1847 }
1848}
1849impl<'a, T> FusedIterator for Tuple17Iter<'a, T> {}
1850impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1851 type Iter = Tuple17Iter<'a, T>;
1852 #[inline]
1853 fn iter(&'a self) -> Self::Iter {
1854 Tuple17Iter::new(self)
1855 }
1856}
1857pub struct Tuple17IntoIter<T>([MaybeUninit<T>; 17], Range<usize>);
1858impl<T> Tuple17IntoIter<T> {
1859 #[inline]
1860 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1861 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16)], 0..17)
1862 }
1863}
1864impl<T> Iterator for Tuple17IntoIter<T> {
1865 type Item = T;
1866 #[inline]
1867 fn next(&mut self) -> Option<Self::Item> {
1868 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1869 }
1870 #[inline]
1871 fn size_hint(&self) -> (usize, Option<usize>) {
1872 let len = self.len();
1873 (len, Some(len))
1874 }
1875 #[inline]
1876 fn count(self) -> usize {
1877 self.len()
1878 }
1879 #[inline]
1880 fn last(mut self) -> Option<Self::Item> {
1881 self.next_back()
1882 }
1883}
1884impl<T> DoubleEndedIterator for Tuple17IntoIter<T> {
1885 fn next_back(&mut self) -> Option<Self::Item> {
1886 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1887 }
1888}
1889impl<T> ExactSizeIterator for Tuple17IntoIter<T> {
1890 #[inline]
1891 fn len(&self) -> usize {
1892 self.1.end - self.1.start
1893 }
1894}
1895impl<T> FusedIterator for Tuple17IntoIter<T> {}
1896impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1897 type Iter = Tuple17IntoIter<T>;
1898 #[inline]
1899 fn into_iter(self) -> Self::Iter {
1900 Tuple17IntoIter::new(self)
1901 }
1902}
1903impl<T> Drop for Tuple17IntoIter<T> {
1904 fn drop(&mut self) {
1905 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
1906 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
1907 unsafe { core::ptr::drop_in_place(slice) }
1908 }
1909}
1910impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1911 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
1912 let mut iter = iter.into_iter();
1913 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
1914 }
1915}
1916impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1917 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
1918 let mut iter = iter.into_iter();
1919 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
1920 }
1921}
1922impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1923 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
1924 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
1925 let mut iter = iter.into_iter();
1926 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
1927 }
1928}
1929pub struct Tuple18Iter<'a, T>([&'a T; 18], Range<usize>);
1930impl<'a, T> Tuple18Iter<'a, T> {
1931 #[inline]
1932 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1933 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17], 0..18)
1934 }
1935}
1936impl<'a, T> Iterator for Tuple18Iter<'a, T> {
1937 type Item = &'a T;
1938 #[inline]
1939 fn next(&mut self) -> Option<Self::Item> {
1940 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1941 }
1942 #[inline]
1943 fn size_hint(&self) -> (usize, Option<usize>) {
1944 let len = self.len();
1945 (len, Some(len))
1946 }
1947 #[inline]
1948 fn count(self) -> usize {
1949 self.len()
1950 }
1951 #[inline]
1952 fn last(mut self) -> Option<Self::Item> {
1953 self.next_back()
1954 }
1955}
1956impl<'a, T> DoubleEndedIterator for Tuple18Iter<'a, T> {
1957 #[inline]
1958 fn next_back(&mut self) -> Option<Self::Item> {
1959 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
1960 }
1961}
1962impl<'a, T> ExactSizeIterator for Tuple18Iter<'a, T> {
1963 #[inline]
1964 fn len(&self) -> usize {
1965 self.1.end - self.1.start
1966 }
1967}
1968impl<'a, T> FusedIterator for Tuple18Iter<'a, T> {}
1969impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
1970 type Iter = Tuple18Iter<'a, T>;
1971 #[inline]
1972 fn iter(&'a self) -> Self::Iter {
1973 Tuple18Iter::new(self)
1974 }
1975}
1976pub struct Tuple18IntoIter<T>([MaybeUninit<T>; 18], Range<usize>);
1977impl<T> Tuple18IntoIter<T> {
1978 #[inline]
1979 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
1980 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17)], 0..18)
1981 }
1982}
1983impl<T> Iterator for Tuple18IntoIter<T> {
1984 type Item = T;
1985 #[inline]
1986 fn next(&mut self) -> Option<Self::Item> {
1987 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
1988 }
1989 #[inline]
1990 fn size_hint(&self) -> (usize, Option<usize>) {
1991 let len = self.len();
1992 (len, Some(len))
1993 }
1994 #[inline]
1995 fn count(self) -> usize {
1996 self.len()
1997 }
1998 #[inline]
1999 fn last(mut self) -> Option<Self::Item> {
2000 self.next_back()
2001 }
2002}
2003impl<T> DoubleEndedIterator for Tuple18IntoIter<T> {
2004 fn next_back(&mut self) -> Option<Self::Item> {
2005 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2006 }
2007}
2008impl<T> ExactSizeIterator for Tuple18IntoIter<T> {
2009 #[inline]
2010 fn len(&self) -> usize {
2011 self.1.end - self.1.start
2012 }
2013}
2014impl<T> FusedIterator for Tuple18IntoIter<T> {}
2015impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2016 type Iter = Tuple18IntoIter<T>;
2017 #[inline]
2018 fn into_iter(self) -> Self::Iter {
2019 Tuple18IntoIter::new(self)
2020 }
2021}
2022impl<T> Drop for Tuple18IntoIter<T> {
2023 fn drop(&mut self) {
2024 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
2025 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
2026 unsafe { core::ptr::drop_in_place(slice) }
2027 }
2028}
2029impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2030 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
2031 let mut iter = iter.into_iter();
2032 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
2033 }
2034}
2035impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2036 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
2037 let mut iter = iter.into_iter();
2038 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
2039 }
2040}
2041impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2042 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
2043 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
2044 let mut iter = iter.into_iter();
2045 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
2046 }
2047}
2048pub struct Tuple19Iter<'a, T>([&'a T; 19], Range<usize>);
2049impl<'a, T> Tuple19Iter<'a, T> {
2050 #[inline]
2051 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2052 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18], 0..19)
2053 }
2054}
2055impl<'a, T> Iterator for Tuple19Iter<'a, T> {
2056 type Item = &'a T;
2057 #[inline]
2058 fn next(&mut self) -> Option<Self::Item> {
2059 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2060 }
2061 #[inline]
2062 fn size_hint(&self) -> (usize, Option<usize>) {
2063 let len = self.len();
2064 (len, Some(len))
2065 }
2066 #[inline]
2067 fn count(self) -> usize {
2068 self.len()
2069 }
2070 #[inline]
2071 fn last(mut self) -> Option<Self::Item> {
2072 self.next_back()
2073 }
2074}
2075impl<'a, T> DoubleEndedIterator for Tuple19Iter<'a, T> {
2076 #[inline]
2077 fn next_back(&mut self) -> Option<Self::Item> {
2078 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2079 }
2080}
2081impl<'a, T> ExactSizeIterator for Tuple19Iter<'a, T> {
2082 #[inline]
2083 fn len(&self) -> usize {
2084 self.1.end - self.1.start
2085 }
2086}
2087impl<'a, T> FusedIterator for Tuple19Iter<'a, T> {}
2088impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2089 type Iter = Tuple19Iter<'a, T>;
2090 #[inline]
2091 fn iter(&'a self) -> Self::Iter {
2092 Tuple19Iter::new(self)
2093 }
2094}
2095pub struct Tuple19IntoIter<T>([MaybeUninit<T>; 19], Range<usize>);
2096impl<T> Tuple19IntoIter<T> {
2097 #[inline]
2098 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2099 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18)], 0..19)
2100 }
2101}
2102impl<T> Iterator for Tuple19IntoIter<T> {
2103 type Item = T;
2104 #[inline]
2105 fn next(&mut self) -> Option<Self::Item> {
2106 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2107 }
2108 #[inline]
2109 fn size_hint(&self) -> (usize, Option<usize>) {
2110 let len = self.len();
2111 (len, Some(len))
2112 }
2113 #[inline]
2114 fn count(self) -> usize {
2115 self.len()
2116 }
2117 #[inline]
2118 fn last(mut self) -> Option<Self::Item> {
2119 self.next_back()
2120 }
2121}
2122impl<T> DoubleEndedIterator for Tuple19IntoIter<T> {
2123 fn next_back(&mut self) -> Option<Self::Item> {
2124 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2125 }
2126}
2127impl<T> ExactSizeIterator for Tuple19IntoIter<T> {
2128 #[inline]
2129 fn len(&self) -> usize {
2130 self.1.end - self.1.start
2131 }
2132}
2133impl<T> FusedIterator for Tuple19IntoIter<T> {}
2134impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2135 type Iter = Tuple19IntoIter<T>;
2136 #[inline]
2137 fn into_iter(self) -> Self::Iter {
2138 Tuple19IntoIter::new(self)
2139 }
2140}
2141impl<T> Drop for Tuple19IntoIter<T> {
2142 fn drop(&mut self) {
2143 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
2144 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
2145 unsafe { core::ptr::drop_in_place(slice) }
2146 }
2147}
2148impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2149 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
2150 let mut iter = iter.into_iter();
2151 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
2152 }
2153}
2154impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2155 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
2156 let mut iter = iter.into_iter();
2157 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
2158 }
2159}
2160impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2161 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
2162 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
2163 let mut iter = iter.into_iter();
2164 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
2165 }
2166}
2167pub struct Tuple20Iter<'a, T>([&'a T; 20], Range<usize>);
2168impl<'a, T> Tuple20Iter<'a, T> {
2169 #[inline]
2170 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2171 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19], 0..20)
2172 }
2173}
2174impl<'a, T> Iterator for Tuple20Iter<'a, T> {
2175 type Item = &'a T;
2176 #[inline]
2177 fn next(&mut self) -> Option<Self::Item> {
2178 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2179 }
2180 #[inline]
2181 fn size_hint(&self) -> (usize, Option<usize>) {
2182 let len = self.len();
2183 (len, Some(len))
2184 }
2185 #[inline]
2186 fn count(self) -> usize {
2187 self.len()
2188 }
2189 #[inline]
2190 fn last(mut self) -> Option<Self::Item> {
2191 self.next_back()
2192 }
2193}
2194impl<'a, T> DoubleEndedIterator for Tuple20Iter<'a, T> {
2195 #[inline]
2196 fn next_back(&mut self) -> Option<Self::Item> {
2197 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2198 }
2199}
2200impl<'a, T> ExactSizeIterator for Tuple20Iter<'a, T> {
2201 #[inline]
2202 fn len(&self) -> usize {
2203 self.1.end - self.1.start
2204 }
2205}
2206impl<'a, T> FusedIterator for Tuple20Iter<'a, T> {}
2207impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2208 type Iter = Tuple20Iter<'a, T>;
2209 #[inline]
2210 fn iter(&'a self) -> Self::Iter {
2211 Tuple20Iter::new(self)
2212 }
2213}
2214pub struct Tuple20IntoIter<T>([MaybeUninit<T>; 20], Range<usize>);
2215impl<T> Tuple20IntoIter<T> {
2216 #[inline]
2217 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2218 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19)], 0..20)
2219 }
2220}
2221impl<T> Iterator for Tuple20IntoIter<T> {
2222 type Item = T;
2223 #[inline]
2224 fn next(&mut self) -> Option<Self::Item> {
2225 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2226 }
2227 #[inline]
2228 fn size_hint(&self) -> (usize, Option<usize>) {
2229 let len = self.len();
2230 (len, Some(len))
2231 }
2232 #[inline]
2233 fn count(self) -> usize {
2234 self.len()
2235 }
2236 #[inline]
2237 fn last(mut self) -> Option<Self::Item> {
2238 self.next_back()
2239 }
2240}
2241impl<T> DoubleEndedIterator for Tuple20IntoIter<T> {
2242 fn next_back(&mut self) -> Option<Self::Item> {
2243 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2244 }
2245}
2246impl<T> ExactSizeIterator for Tuple20IntoIter<T> {
2247 #[inline]
2248 fn len(&self) -> usize {
2249 self.1.end - self.1.start
2250 }
2251}
2252impl<T> FusedIterator for Tuple20IntoIter<T> {}
2253impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2254 type Iter = Tuple20IntoIter<T>;
2255 #[inline]
2256 fn into_iter(self) -> Self::Iter {
2257 Tuple20IntoIter::new(self)
2258 }
2259}
2260impl<T> Drop for Tuple20IntoIter<T> {
2261 fn drop(&mut self) {
2262 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
2263 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
2264 unsafe { core::ptr::drop_in_place(slice) }
2265 }
2266}
2267impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2268 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
2269 let mut iter = iter.into_iter();
2270 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
2271 }
2272}
2273impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2274 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
2275 let mut iter = iter.into_iter();
2276 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
2277 }
2278}
2279impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2280 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
2281 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
2282 let mut iter = iter.into_iter();
2283 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
2284 }
2285}
2286pub struct Tuple21Iter<'a, T>([&'a T; 21], Range<usize>);
2287impl<'a, T> Tuple21Iter<'a, T> {
2288 #[inline]
2289 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2290 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20], 0..21)
2291 }
2292}
2293impl<'a, T> Iterator for Tuple21Iter<'a, T> {
2294 type Item = &'a T;
2295 #[inline]
2296 fn next(&mut self) -> Option<Self::Item> {
2297 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2298 }
2299 #[inline]
2300 fn size_hint(&self) -> (usize, Option<usize>) {
2301 let len = self.len();
2302 (len, Some(len))
2303 }
2304 #[inline]
2305 fn count(self) -> usize {
2306 self.len()
2307 }
2308 #[inline]
2309 fn last(mut self) -> Option<Self::Item> {
2310 self.next_back()
2311 }
2312}
2313impl<'a, T> DoubleEndedIterator for Tuple21Iter<'a, T> {
2314 #[inline]
2315 fn next_back(&mut self) -> Option<Self::Item> {
2316 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2317 }
2318}
2319impl<'a, T> ExactSizeIterator for Tuple21Iter<'a, T> {
2320 #[inline]
2321 fn len(&self) -> usize {
2322 self.1.end - self.1.start
2323 }
2324}
2325impl<'a, T> FusedIterator for Tuple21Iter<'a, T> {}
2326impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2327 type Iter = Tuple21Iter<'a, T>;
2328 #[inline]
2329 fn iter(&'a self) -> Self::Iter {
2330 Tuple21Iter::new(self)
2331 }
2332}
2333pub struct Tuple21IntoIter<T>([MaybeUninit<T>; 21], Range<usize>);
2334impl<T> Tuple21IntoIter<T> {
2335 #[inline]
2336 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2337 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20)], 0..21)
2338 }
2339}
2340impl<T> Iterator for Tuple21IntoIter<T> {
2341 type Item = T;
2342 #[inline]
2343 fn next(&mut self) -> Option<Self::Item> {
2344 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2345 }
2346 #[inline]
2347 fn size_hint(&self) -> (usize, Option<usize>) {
2348 let len = self.len();
2349 (len, Some(len))
2350 }
2351 #[inline]
2352 fn count(self) -> usize {
2353 self.len()
2354 }
2355 #[inline]
2356 fn last(mut self) -> Option<Self::Item> {
2357 self.next_back()
2358 }
2359}
2360impl<T> DoubleEndedIterator for Tuple21IntoIter<T> {
2361 fn next_back(&mut self) -> Option<Self::Item> {
2362 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2363 }
2364}
2365impl<T> ExactSizeIterator for Tuple21IntoIter<T> {
2366 #[inline]
2367 fn len(&self) -> usize {
2368 self.1.end - self.1.start
2369 }
2370}
2371impl<T> FusedIterator for Tuple21IntoIter<T> {}
2372impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2373 type Iter = Tuple21IntoIter<T>;
2374 #[inline]
2375 fn into_iter(self) -> Self::Iter {
2376 Tuple21IntoIter::new(self)
2377 }
2378}
2379impl<T> Drop for Tuple21IntoIter<T> {
2380 fn drop(&mut self) {
2381 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
2382 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
2383 unsafe { core::ptr::drop_in_place(slice) }
2384 }
2385}
2386impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2387 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
2388 let mut iter = iter.into_iter();
2389 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
2390 }
2391}
2392impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2393 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
2394 let mut iter = iter.into_iter();
2395 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
2396 }
2397}
2398impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2399 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
2400 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
2401 let mut iter = iter.into_iter();
2402 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
2403 }
2404}
2405pub struct Tuple22Iter<'a, T>([&'a T; 22], Range<usize>);
2406impl<'a, T> Tuple22Iter<'a, T> {
2407 #[inline]
2408 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2409 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20, &t.21], 0..22)
2410 }
2411}
2412impl<'a, T> Iterator for Tuple22Iter<'a, T> {
2413 type Item = &'a T;
2414 #[inline]
2415 fn next(&mut self) -> Option<Self::Item> {
2416 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2417 }
2418 #[inline]
2419 fn size_hint(&self) -> (usize, Option<usize>) {
2420 let len = self.len();
2421 (len, Some(len))
2422 }
2423 #[inline]
2424 fn count(self) -> usize {
2425 self.len()
2426 }
2427 #[inline]
2428 fn last(mut self) -> Option<Self::Item> {
2429 self.next_back()
2430 }
2431}
2432impl<'a, T> DoubleEndedIterator for Tuple22Iter<'a, T> {
2433 #[inline]
2434 fn next_back(&mut self) -> Option<Self::Item> {
2435 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2436 }
2437}
2438impl<'a, T> ExactSizeIterator for Tuple22Iter<'a, T> {
2439 #[inline]
2440 fn len(&self) -> usize {
2441 self.1.end - self.1.start
2442 }
2443}
2444impl<'a, T> FusedIterator for Tuple22Iter<'a, T> {}
2445impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2446 type Iter = Tuple22Iter<'a, T>;
2447 #[inline]
2448 fn iter(&'a self) -> Self::Iter {
2449 Tuple22Iter::new(self)
2450 }
2451}
2452pub struct Tuple22IntoIter<T>([MaybeUninit<T>; 22], Range<usize>);
2453impl<T> Tuple22IntoIter<T> {
2454 #[inline]
2455 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2456 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20), MaybeUninit::new(t.21)], 0..22)
2457 }
2458}
2459impl<T> Iterator for Tuple22IntoIter<T> {
2460 type Item = T;
2461 #[inline]
2462 fn next(&mut self) -> Option<Self::Item> {
2463 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2464 }
2465 #[inline]
2466 fn size_hint(&self) -> (usize, Option<usize>) {
2467 let len = self.len();
2468 (len, Some(len))
2469 }
2470 #[inline]
2471 fn count(self) -> usize {
2472 self.len()
2473 }
2474 #[inline]
2475 fn last(mut self) -> Option<Self::Item> {
2476 self.next_back()
2477 }
2478}
2479impl<T> DoubleEndedIterator for Tuple22IntoIter<T> {
2480 fn next_back(&mut self) -> Option<Self::Item> {
2481 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2482 }
2483}
2484impl<T> ExactSizeIterator for Tuple22IntoIter<T> {
2485 #[inline]
2486 fn len(&self) -> usize {
2487 self.1.end - self.1.start
2488 }
2489}
2490impl<T> FusedIterator for Tuple22IntoIter<T> {}
2491impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2492 type Iter = Tuple22IntoIter<T>;
2493 #[inline]
2494 fn into_iter(self) -> Self::Iter {
2495 Tuple22IntoIter::new(self)
2496 }
2497}
2498impl<T> Drop for Tuple22IntoIter<T> {
2499 fn drop(&mut self) {
2500 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
2501 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
2502 unsafe { core::ptr::drop_in_place(slice) }
2503 }
2504}
2505impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2506 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
2507 let mut iter = iter.into_iter();
2508 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
2509 }
2510}
2511impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2512 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
2513 let mut iter = iter.into_iter();
2514 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
2515 }
2516}
2517impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2518 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
2519 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
2520 let mut iter = iter.into_iter();
2521 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
2522 }
2523}
2524pub struct Tuple23Iter<'a, T>([&'a T; 23], Range<usize>);
2525impl<'a, T> Tuple23Iter<'a, T> {
2526 #[inline]
2527 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2528 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20, &t.21, &t.22], 0..23)
2529 }
2530}
2531impl<'a, T> Iterator for Tuple23Iter<'a, T> {
2532 type Item = &'a T;
2533 #[inline]
2534 fn next(&mut self) -> Option<Self::Item> {
2535 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2536 }
2537 #[inline]
2538 fn size_hint(&self) -> (usize, Option<usize>) {
2539 let len = self.len();
2540 (len, Some(len))
2541 }
2542 #[inline]
2543 fn count(self) -> usize {
2544 self.len()
2545 }
2546 #[inline]
2547 fn last(mut self) -> Option<Self::Item> {
2548 self.next_back()
2549 }
2550}
2551impl<'a, T> DoubleEndedIterator for Tuple23Iter<'a, T> {
2552 #[inline]
2553 fn next_back(&mut self) -> Option<Self::Item> {
2554 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2555 }
2556}
2557impl<'a, T> ExactSizeIterator for Tuple23Iter<'a, T> {
2558 #[inline]
2559 fn len(&self) -> usize {
2560 self.1.end - self.1.start
2561 }
2562}
2563impl<'a, T> FusedIterator for Tuple23Iter<'a, T> {}
2564impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2565 type Iter = Tuple23Iter<'a, T>;
2566 #[inline]
2567 fn iter(&'a self) -> Self::Iter {
2568 Tuple23Iter::new(self)
2569 }
2570}
2571pub struct Tuple23IntoIter<T>([MaybeUninit<T>; 23], Range<usize>);
2572impl<T> Tuple23IntoIter<T> {
2573 #[inline]
2574 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2575 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20), MaybeUninit::new(t.21), MaybeUninit::new(t.22)], 0..23)
2576 }
2577}
2578impl<T> Iterator for Tuple23IntoIter<T> {
2579 type Item = T;
2580 #[inline]
2581 fn next(&mut self) -> Option<Self::Item> {
2582 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2583 }
2584 #[inline]
2585 fn size_hint(&self) -> (usize, Option<usize>) {
2586 let len = self.len();
2587 (len, Some(len))
2588 }
2589 #[inline]
2590 fn count(self) -> usize {
2591 self.len()
2592 }
2593 #[inline]
2594 fn last(mut self) -> Option<Self::Item> {
2595 self.next_back()
2596 }
2597}
2598impl<T> DoubleEndedIterator for Tuple23IntoIter<T> {
2599 fn next_back(&mut self) -> Option<Self::Item> {
2600 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2601 }
2602}
2603impl<T> ExactSizeIterator for Tuple23IntoIter<T> {
2604 #[inline]
2605 fn len(&self) -> usize {
2606 self.1.end - self.1.start
2607 }
2608}
2609impl<T> FusedIterator for Tuple23IntoIter<T> {}
2610impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2611 type Iter = Tuple23IntoIter<T>;
2612 #[inline]
2613 fn into_iter(self) -> Self::Iter {
2614 Tuple23IntoIter::new(self)
2615 }
2616}
2617impl<T> Drop for Tuple23IntoIter<T> {
2618 fn drop(&mut self) {
2619 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
2620 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
2621 unsafe { core::ptr::drop_in_place(slice) }
2622 }
2623}
2624impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2625 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
2626 let mut iter = iter.into_iter();
2627 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
2628 }
2629}
2630impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2631 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
2632 let mut iter = iter.into_iter();
2633 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
2634 }
2635}
2636impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2637 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
2638 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
2639 let mut iter = iter.into_iter();
2640 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
2641 }
2642}
2643pub struct Tuple24Iter<'a, T>([&'a T; 24], Range<usize>);
2644impl<'a, T> Tuple24Iter<'a, T> {
2645 #[inline]
2646 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2647 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20, &t.21, &t.22, &t.23], 0..24)
2648 }
2649}
2650impl<'a, T> Iterator for Tuple24Iter<'a, T> {
2651 type Item = &'a T;
2652 #[inline]
2653 fn next(&mut self) -> Option<Self::Item> {
2654 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2655 }
2656 #[inline]
2657 fn size_hint(&self) -> (usize, Option<usize>) {
2658 let len = self.len();
2659 (len, Some(len))
2660 }
2661 #[inline]
2662 fn count(self) -> usize {
2663 self.len()
2664 }
2665 #[inline]
2666 fn last(mut self) -> Option<Self::Item> {
2667 self.next_back()
2668 }
2669}
2670impl<'a, T> DoubleEndedIterator for Tuple24Iter<'a, T> {
2671 #[inline]
2672 fn next_back(&mut self) -> Option<Self::Item> {
2673 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2674 }
2675}
2676impl<'a, T> ExactSizeIterator for Tuple24Iter<'a, T> {
2677 #[inline]
2678 fn len(&self) -> usize {
2679 self.1.end - self.1.start
2680 }
2681}
2682impl<'a, T> FusedIterator for Tuple24Iter<'a, T> {}
2683impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2684 type Iter = Tuple24Iter<'a, T>;
2685 #[inline]
2686 fn iter(&'a self) -> Self::Iter {
2687 Tuple24Iter::new(self)
2688 }
2689}
2690pub struct Tuple24IntoIter<T>([MaybeUninit<T>; 24], Range<usize>);
2691impl<T> Tuple24IntoIter<T> {
2692 #[inline]
2693 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2694 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20), MaybeUninit::new(t.21), MaybeUninit::new(t.22), MaybeUninit::new(t.23)], 0..24)
2695 }
2696}
2697impl<T> Iterator for Tuple24IntoIter<T> {
2698 type Item = T;
2699 #[inline]
2700 fn next(&mut self) -> Option<Self::Item> {
2701 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2702 }
2703 #[inline]
2704 fn size_hint(&self) -> (usize, Option<usize>) {
2705 let len = self.len();
2706 (len, Some(len))
2707 }
2708 #[inline]
2709 fn count(self) -> usize {
2710 self.len()
2711 }
2712 #[inline]
2713 fn last(mut self) -> Option<Self::Item> {
2714 self.next_back()
2715 }
2716}
2717impl<T> DoubleEndedIterator for Tuple24IntoIter<T> {
2718 fn next_back(&mut self) -> Option<Self::Item> {
2719 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2720 }
2721}
2722impl<T> ExactSizeIterator for Tuple24IntoIter<T> {
2723 #[inline]
2724 fn len(&self) -> usize {
2725 self.1.end - self.1.start
2726 }
2727}
2728impl<T> FusedIterator for Tuple24IntoIter<T> {}
2729impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2730 type Iter = Tuple24IntoIter<T>;
2731 #[inline]
2732 fn into_iter(self) -> Self::Iter {
2733 Tuple24IntoIter::new(self)
2734 }
2735}
2736impl<T> Drop for Tuple24IntoIter<T> {
2737 fn drop(&mut self) {
2738 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
2739 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
2740 unsafe { core::ptr::drop_in_place(slice) }
2741 }
2742}
2743impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2744 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
2745 let mut iter = iter.into_iter();
2746 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
2747 }
2748}
2749impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2750 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
2751 let mut iter = iter.into_iter();
2752 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
2753 }
2754}
2755impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2756 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
2757 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
2758 let mut iter = iter.into_iter();
2759 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
2760 }
2761}
2762pub struct Tuple25Iter<'a, T>([&'a T; 25], Range<usize>);
2763impl<'a, T> Tuple25Iter<'a, T> {
2764 #[inline]
2765 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2766 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20, &t.21, &t.22, &t.23, &t.24], 0..25)
2767 }
2768}
2769impl<'a, T> Iterator for Tuple25Iter<'a, T> {
2770 type Item = &'a T;
2771 #[inline]
2772 fn next(&mut self) -> Option<Self::Item> {
2773 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2774 }
2775 #[inline]
2776 fn size_hint(&self) -> (usize, Option<usize>) {
2777 let len = self.len();
2778 (len, Some(len))
2779 }
2780 #[inline]
2781 fn count(self) -> usize {
2782 self.len()
2783 }
2784 #[inline]
2785 fn last(mut self) -> Option<Self::Item> {
2786 self.next_back()
2787 }
2788}
2789impl<'a, T> DoubleEndedIterator for Tuple25Iter<'a, T> {
2790 #[inline]
2791 fn next_back(&mut self) -> Option<Self::Item> {
2792 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2793 }
2794}
2795impl<'a, T> ExactSizeIterator for Tuple25Iter<'a, T> {
2796 #[inline]
2797 fn len(&self) -> usize {
2798 self.1.end - self.1.start
2799 }
2800}
2801impl<'a, T> FusedIterator for Tuple25Iter<'a, T> {}
2802impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2803 type Iter = Tuple25Iter<'a, T>;
2804 #[inline]
2805 fn iter(&'a self) -> Self::Iter {
2806 Tuple25Iter::new(self)
2807 }
2808}
2809pub struct Tuple25IntoIter<T>([MaybeUninit<T>; 25], Range<usize>);
2810impl<T> Tuple25IntoIter<T> {
2811 #[inline]
2812 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2813 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20), MaybeUninit::new(t.21), MaybeUninit::new(t.22), MaybeUninit::new(t.23), MaybeUninit::new(t.24)], 0..25)
2814 }
2815}
2816impl<T> Iterator for Tuple25IntoIter<T> {
2817 type Item = T;
2818 #[inline]
2819 fn next(&mut self) -> Option<Self::Item> {
2820 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2821 }
2822 #[inline]
2823 fn size_hint(&self) -> (usize, Option<usize>) {
2824 let len = self.len();
2825 (len, Some(len))
2826 }
2827 #[inline]
2828 fn count(self) -> usize {
2829 self.len()
2830 }
2831 #[inline]
2832 fn last(mut self) -> Option<Self::Item> {
2833 self.next_back()
2834 }
2835}
2836impl<T> DoubleEndedIterator for Tuple25IntoIter<T> {
2837 fn next_back(&mut self) -> Option<Self::Item> {
2838 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2839 }
2840}
2841impl<T> ExactSizeIterator for Tuple25IntoIter<T> {
2842 #[inline]
2843 fn len(&self) -> usize {
2844 self.1.end - self.1.start
2845 }
2846}
2847impl<T> FusedIterator for Tuple25IntoIter<T> {}
2848impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2849 type Iter = Tuple25IntoIter<T>;
2850 #[inline]
2851 fn into_iter(self) -> Self::Iter {
2852 Tuple25IntoIter::new(self)
2853 }
2854}
2855impl<T> Drop for Tuple25IntoIter<T> {
2856 fn drop(&mut self) {
2857 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
2858 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
2859 unsafe { core::ptr::drop_in_place(slice) }
2860 }
2861}
2862impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2863 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
2864 let mut iter = iter.into_iter();
2865 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
2866 }
2867}
2868impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2869 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
2870 let mut iter = iter.into_iter();
2871 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
2872 }
2873}
2874impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2875 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
2876 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
2877 let mut iter = iter.into_iter();
2878 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
2879 }
2880}
2881pub struct Tuple26Iter<'a, T>([&'a T; 26], Range<usize>);
2882impl<'a, T> Tuple26Iter<'a, T> {
2883 #[inline]
2884 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2885 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20, &t.21, &t.22, &t.23, &t.24, &t.25], 0..26)
2886 }
2887}
2888impl<'a, T> Iterator for Tuple26Iter<'a, T> {
2889 type Item = &'a T;
2890 #[inline]
2891 fn next(&mut self) -> Option<Self::Item> {
2892 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2893 }
2894 #[inline]
2895 fn size_hint(&self) -> (usize, Option<usize>) {
2896 let len = self.len();
2897 (len, Some(len))
2898 }
2899 #[inline]
2900 fn count(self) -> usize {
2901 self.len()
2902 }
2903 #[inline]
2904 fn last(mut self) -> Option<Self::Item> {
2905 self.next_back()
2906 }
2907}
2908impl<'a, T> DoubleEndedIterator for Tuple26Iter<'a, T> {
2909 #[inline]
2910 fn next_back(&mut self) -> Option<Self::Item> {
2911 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
2912 }
2913}
2914impl<'a, T> ExactSizeIterator for Tuple26Iter<'a, T> {
2915 #[inline]
2916 fn len(&self) -> usize {
2917 self.1.end - self.1.start
2918 }
2919}
2920impl<'a, T> FusedIterator for Tuple26Iter<'a, T> {}
2921impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2922 type Iter = Tuple26Iter<'a, T>;
2923 #[inline]
2924 fn iter(&'a self) -> Self::Iter {
2925 Tuple26Iter::new(self)
2926 }
2927}
2928pub struct Tuple26IntoIter<T>([MaybeUninit<T>; 26], Range<usize>);
2929impl<T> Tuple26IntoIter<T> {
2930 #[inline]
2931 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
2932 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20), MaybeUninit::new(t.21), MaybeUninit::new(t.22), MaybeUninit::new(t.23), MaybeUninit::new(t.24), MaybeUninit::new(t.25)], 0..26)
2933 }
2934}
2935impl<T> Iterator for Tuple26IntoIter<T> {
2936 type Item = T;
2937 #[inline]
2938 fn next(&mut self) -> Option<Self::Item> {
2939 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2940 }
2941 #[inline]
2942 fn size_hint(&self) -> (usize, Option<usize>) {
2943 let len = self.len();
2944 (len, Some(len))
2945 }
2946 #[inline]
2947 fn count(self) -> usize {
2948 self.len()
2949 }
2950 #[inline]
2951 fn last(mut self) -> Option<Self::Item> {
2952 self.next_back()
2953 }
2954}
2955impl<T> DoubleEndedIterator for Tuple26IntoIter<T> {
2956 fn next_back(&mut self) -> Option<Self::Item> {
2957 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
2958 }
2959}
2960impl<T> ExactSizeIterator for Tuple26IntoIter<T> {
2961 #[inline]
2962 fn len(&self) -> usize {
2963 self.1.end - self.1.start
2964 }
2965}
2966impl<T> FusedIterator for Tuple26IntoIter<T> {}
2967impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2968 type Iter = Tuple26IntoIter<T>;
2969 #[inline]
2970 fn into_iter(self) -> Self::Iter {
2971 Tuple26IntoIter::new(self)
2972 }
2973}
2974impl<T> Drop for Tuple26IntoIter<T> {
2975 fn drop(&mut self) {
2976 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
2977 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
2978 unsafe { core::ptr::drop_in_place(slice) }
2979 }
2980}
2981impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2982 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
2983 let mut iter = iter.into_iter();
2984 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
2985 }
2986}
2987impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2988 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
2989 let mut iter = iter.into_iter();
2990 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
2991 }
2992}
2993impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
2994 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
2995 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
2996 let mut iter = iter.into_iter();
2997 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
2998 }
2999}
3000pub struct Tuple27Iter<'a, T>([&'a T; 27], Range<usize>);
3001impl<'a, T> Tuple27Iter<'a, T> {
3002 #[inline]
3003 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3004 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20, &t.21, &t.22, &t.23, &t.24, &t.25, &t.26], 0..27)
3005 }
3006}
3007impl<'a, T> Iterator for Tuple27Iter<'a, T> {
3008 type Item = &'a T;
3009 #[inline]
3010 fn next(&mut self) -> Option<Self::Item> {
3011 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3012 }
3013 #[inline]
3014 fn size_hint(&self) -> (usize, Option<usize>) {
3015 let len = self.len();
3016 (len, Some(len))
3017 }
3018 #[inline]
3019 fn count(self) -> usize {
3020 self.len()
3021 }
3022 #[inline]
3023 fn last(mut self) -> Option<Self::Item> {
3024 self.next_back()
3025 }
3026}
3027impl<'a, T> DoubleEndedIterator for Tuple27Iter<'a, T> {
3028 #[inline]
3029 fn next_back(&mut self) -> Option<Self::Item> {
3030 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3031 }
3032}
3033impl<'a, T> ExactSizeIterator for Tuple27Iter<'a, T> {
3034 #[inline]
3035 fn len(&self) -> usize {
3036 self.1.end - self.1.start
3037 }
3038}
3039impl<'a, T> FusedIterator for Tuple27Iter<'a, T> {}
3040impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3041 type Iter = Tuple27Iter<'a, T>;
3042 #[inline]
3043 fn iter(&'a self) -> Self::Iter {
3044 Tuple27Iter::new(self)
3045 }
3046}
3047pub struct Tuple27IntoIter<T>([MaybeUninit<T>; 27], Range<usize>);
3048impl<T> Tuple27IntoIter<T> {
3049 #[inline]
3050 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3051 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20), MaybeUninit::new(t.21), MaybeUninit::new(t.22), MaybeUninit::new(t.23), MaybeUninit::new(t.24), MaybeUninit::new(t.25), MaybeUninit::new(t.26)], 0..27)
3052 }
3053}
3054impl<T> Iterator for Tuple27IntoIter<T> {
3055 type Item = T;
3056 #[inline]
3057 fn next(&mut self) -> Option<Self::Item> {
3058 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3059 }
3060 #[inline]
3061 fn size_hint(&self) -> (usize, Option<usize>) {
3062 let len = self.len();
3063 (len, Some(len))
3064 }
3065 #[inline]
3066 fn count(self) -> usize {
3067 self.len()
3068 }
3069 #[inline]
3070 fn last(mut self) -> Option<Self::Item> {
3071 self.next_back()
3072 }
3073}
3074impl<T> DoubleEndedIterator for Tuple27IntoIter<T> {
3075 fn next_back(&mut self) -> Option<Self::Item> {
3076 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3077 }
3078}
3079impl<T> ExactSizeIterator for Tuple27IntoIter<T> {
3080 #[inline]
3081 fn len(&self) -> usize {
3082 self.1.end - self.1.start
3083 }
3084}
3085impl<T> FusedIterator for Tuple27IntoIter<T> {}
3086impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3087 type Iter = Tuple27IntoIter<T>;
3088 #[inline]
3089 fn into_iter(self) -> Self::Iter {
3090 Tuple27IntoIter::new(self)
3091 }
3092}
3093impl<T> Drop for Tuple27IntoIter<T> {
3094 fn drop(&mut self) {
3095 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
3096 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
3097 unsafe { core::ptr::drop_in_place(slice) }
3098 }
3099}
3100impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3101 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
3102 let mut iter = iter.into_iter();
3103 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
3104 }
3105}
3106impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3107 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
3108 let mut iter = iter.into_iter();
3109 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
3110 }
3111}
3112impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3113 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
3114 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
3115 let mut iter = iter.into_iter();
3116 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
3117 }
3118}
3119pub struct Tuple28Iter<'a, T>([&'a T; 28], Range<usize>);
3120impl<'a, T> Tuple28Iter<'a, T> {
3121 #[inline]
3122 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3123 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20, &t.21, &t.22, &t.23, &t.24, &t.25, &t.26, &t.27], 0..28)
3124 }
3125}
3126impl<'a, T> Iterator for Tuple28Iter<'a, T> {
3127 type Item = &'a T;
3128 #[inline]
3129 fn next(&mut self) -> Option<Self::Item> {
3130 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3131 }
3132 #[inline]
3133 fn size_hint(&self) -> (usize, Option<usize>) {
3134 let len = self.len();
3135 (len, Some(len))
3136 }
3137 #[inline]
3138 fn count(self) -> usize {
3139 self.len()
3140 }
3141 #[inline]
3142 fn last(mut self) -> Option<Self::Item> {
3143 self.next_back()
3144 }
3145}
3146impl<'a, T> DoubleEndedIterator for Tuple28Iter<'a, T> {
3147 #[inline]
3148 fn next_back(&mut self) -> Option<Self::Item> {
3149 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3150 }
3151}
3152impl<'a, T> ExactSizeIterator for Tuple28Iter<'a, T> {
3153 #[inline]
3154 fn len(&self) -> usize {
3155 self.1.end - self.1.start
3156 }
3157}
3158impl<'a, T> FusedIterator for Tuple28Iter<'a, T> {}
3159impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3160 type Iter = Tuple28Iter<'a, T>;
3161 #[inline]
3162 fn iter(&'a self) -> Self::Iter {
3163 Tuple28Iter::new(self)
3164 }
3165}
3166pub struct Tuple28IntoIter<T>([MaybeUninit<T>; 28], Range<usize>);
3167impl<T> Tuple28IntoIter<T> {
3168 #[inline]
3169 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3170 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20), MaybeUninit::new(t.21), MaybeUninit::new(t.22), MaybeUninit::new(t.23), MaybeUninit::new(t.24), MaybeUninit::new(t.25), MaybeUninit::new(t.26), MaybeUninit::new(t.27)], 0..28)
3171 }
3172}
3173impl<T> Iterator for Tuple28IntoIter<T> {
3174 type Item = T;
3175 #[inline]
3176 fn next(&mut self) -> Option<Self::Item> {
3177 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3178 }
3179 #[inline]
3180 fn size_hint(&self) -> (usize, Option<usize>) {
3181 let len = self.len();
3182 (len, Some(len))
3183 }
3184 #[inline]
3185 fn count(self) -> usize {
3186 self.len()
3187 }
3188 #[inline]
3189 fn last(mut self) -> Option<Self::Item> {
3190 self.next_back()
3191 }
3192}
3193impl<T> DoubleEndedIterator for Tuple28IntoIter<T> {
3194 fn next_back(&mut self) -> Option<Self::Item> {
3195 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3196 }
3197}
3198impl<T> ExactSizeIterator for Tuple28IntoIter<T> {
3199 #[inline]
3200 fn len(&self) -> usize {
3201 self.1.end - self.1.start
3202 }
3203}
3204impl<T> FusedIterator for Tuple28IntoIter<T> {}
3205impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3206 type Iter = Tuple28IntoIter<T>;
3207 #[inline]
3208 fn into_iter(self) -> Self::Iter {
3209 Tuple28IntoIter::new(self)
3210 }
3211}
3212impl<T> Drop for Tuple28IntoIter<T> {
3213 fn drop(&mut self) {
3214 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
3215 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
3216 unsafe { core::ptr::drop_in_place(slice) }
3217 }
3218}
3219impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3220 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
3221 let mut iter = iter.into_iter();
3222 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
3223 }
3224}
3225impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3226 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
3227 let mut iter = iter.into_iter();
3228 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
3229 }
3230}
3231impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3232 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
3233 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
3234 let mut iter = iter.into_iter();
3235 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
3236 }
3237}
3238pub struct Tuple29Iter<'a, T>([&'a T; 29], Range<usize>);
3239impl<'a, T> Tuple29Iter<'a, T> {
3240 #[inline]
3241 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3242 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20, &t.21, &t.22, &t.23, &t.24, &t.25, &t.26, &t.27, &t.28], 0..29)
3243 }
3244}
3245impl<'a, T> Iterator for Tuple29Iter<'a, T> {
3246 type Item = &'a T;
3247 #[inline]
3248 fn next(&mut self) -> Option<Self::Item> {
3249 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3250 }
3251 #[inline]
3252 fn size_hint(&self) -> (usize, Option<usize>) {
3253 let len = self.len();
3254 (len, Some(len))
3255 }
3256 #[inline]
3257 fn count(self) -> usize {
3258 self.len()
3259 }
3260 #[inline]
3261 fn last(mut self) -> Option<Self::Item> {
3262 self.next_back()
3263 }
3264}
3265impl<'a, T> DoubleEndedIterator for Tuple29Iter<'a, T> {
3266 #[inline]
3267 fn next_back(&mut self) -> Option<Self::Item> {
3268 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3269 }
3270}
3271impl<'a, T> ExactSizeIterator for Tuple29Iter<'a, T> {
3272 #[inline]
3273 fn len(&self) -> usize {
3274 self.1.end - self.1.start
3275 }
3276}
3277impl<'a, T> FusedIterator for Tuple29Iter<'a, T> {}
3278impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3279 type Iter = Tuple29Iter<'a, T>;
3280 #[inline]
3281 fn iter(&'a self) -> Self::Iter {
3282 Tuple29Iter::new(self)
3283 }
3284}
3285pub struct Tuple29IntoIter<T>([MaybeUninit<T>; 29], Range<usize>);
3286impl<T> Tuple29IntoIter<T> {
3287 #[inline]
3288 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3289 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20), MaybeUninit::new(t.21), MaybeUninit::new(t.22), MaybeUninit::new(t.23), MaybeUninit::new(t.24), MaybeUninit::new(t.25), MaybeUninit::new(t.26), MaybeUninit::new(t.27), MaybeUninit::new(t.28)], 0..29)
3290 }
3291}
3292impl<T> Iterator for Tuple29IntoIter<T> {
3293 type Item = T;
3294 #[inline]
3295 fn next(&mut self) -> Option<Self::Item> {
3296 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3297 }
3298 #[inline]
3299 fn size_hint(&self) -> (usize, Option<usize>) {
3300 let len = self.len();
3301 (len, Some(len))
3302 }
3303 #[inline]
3304 fn count(self) -> usize {
3305 self.len()
3306 }
3307 #[inline]
3308 fn last(mut self) -> Option<Self::Item> {
3309 self.next_back()
3310 }
3311}
3312impl<T> DoubleEndedIterator for Tuple29IntoIter<T> {
3313 fn next_back(&mut self) -> Option<Self::Item> {
3314 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3315 }
3316}
3317impl<T> ExactSizeIterator for Tuple29IntoIter<T> {
3318 #[inline]
3319 fn len(&self) -> usize {
3320 self.1.end - self.1.start
3321 }
3322}
3323impl<T> FusedIterator for Tuple29IntoIter<T> {}
3324impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3325 type Iter = Tuple29IntoIter<T>;
3326 #[inline]
3327 fn into_iter(self) -> Self::Iter {
3328 Tuple29IntoIter::new(self)
3329 }
3330}
3331impl<T> Drop for Tuple29IntoIter<T> {
3332 fn drop(&mut self) {
3333 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
3334 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
3335 unsafe { core::ptr::drop_in_place(slice) }
3336 }
3337}
3338impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3339 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
3340 let mut iter = iter.into_iter();
3341 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
3342 }
3343}
3344impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3345 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
3346 let mut iter = iter.into_iter();
3347 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
3348 }
3349}
3350impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3351 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
3352 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
3353 let mut iter = iter.into_iter();
3354 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
3355 }
3356}
3357pub struct Tuple30Iter<'a, T>([&'a T; 30], Range<usize>);
3358impl<'a, T> Tuple30Iter<'a, T> {
3359 #[inline]
3360 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3361 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20, &t.21, &t.22, &t.23, &t.24, &t.25, &t.26, &t.27, &t.28, &t.29], 0..30)
3362 }
3363}
3364impl<'a, T> Iterator for Tuple30Iter<'a, T> {
3365 type Item = &'a T;
3366 #[inline]
3367 fn next(&mut self) -> Option<Self::Item> {
3368 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3369 }
3370 #[inline]
3371 fn size_hint(&self) -> (usize, Option<usize>) {
3372 let len = self.len();
3373 (len, Some(len))
3374 }
3375 #[inline]
3376 fn count(self) -> usize {
3377 self.len()
3378 }
3379 #[inline]
3380 fn last(mut self) -> Option<Self::Item> {
3381 self.next_back()
3382 }
3383}
3384impl<'a, T> DoubleEndedIterator for Tuple30Iter<'a, T> {
3385 #[inline]
3386 fn next_back(&mut self) -> Option<Self::Item> {
3387 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3388 }
3389}
3390impl<'a, T> ExactSizeIterator for Tuple30Iter<'a, T> {
3391 #[inline]
3392 fn len(&self) -> usize {
3393 self.1.end - self.1.start
3394 }
3395}
3396impl<'a, T> FusedIterator for Tuple30Iter<'a, T> {}
3397impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3398 type Iter = Tuple30Iter<'a, T>;
3399 #[inline]
3400 fn iter(&'a self) -> Self::Iter {
3401 Tuple30Iter::new(self)
3402 }
3403}
3404pub struct Tuple30IntoIter<T>([MaybeUninit<T>; 30], Range<usize>);
3405impl<T> Tuple30IntoIter<T> {
3406 #[inline]
3407 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3408 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20), MaybeUninit::new(t.21), MaybeUninit::new(t.22), MaybeUninit::new(t.23), MaybeUninit::new(t.24), MaybeUninit::new(t.25), MaybeUninit::new(t.26), MaybeUninit::new(t.27), MaybeUninit::new(t.28), MaybeUninit::new(t.29)], 0..30)
3409 }
3410}
3411impl<T> Iterator for Tuple30IntoIter<T> {
3412 type Item = T;
3413 #[inline]
3414 fn next(&mut self) -> Option<Self::Item> {
3415 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3416 }
3417 #[inline]
3418 fn size_hint(&self) -> (usize, Option<usize>) {
3419 let len = self.len();
3420 (len, Some(len))
3421 }
3422 #[inline]
3423 fn count(self) -> usize {
3424 self.len()
3425 }
3426 #[inline]
3427 fn last(mut self) -> Option<Self::Item> {
3428 self.next_back()
3429 }
3430}
3431impl<T> DoubleEndedIterator for Tuple30IntoIter<T> {
3432 fn next_back(&mut self) -> Option<Self::Item> {
3433 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3434 }
3435}
3436impl<T> ExactSizeIterator for Tuple30IntoIter<T> {
3437 #[inline]
3438 fn len(&self) -> usize {
3439 self.1.end - self.1.start
3440 }
3441}
3442impl<T> FusedIterator for Tuple30IntoIter<T> {}
3443impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3444 type Iter = Tuple30IntoIter<T>;
3445 #[inline]
3446 fn into_iter(self) -> Self::Iter {
3447 Tuple30IntoIter::new(self)
3448 }
3449}
3450impl<T> Drop for Tuple30IntoIter<T> {
3451 fn drop(&mut self) {
3452 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
3453 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
3454 unsafe { core::ptr::drop_in_place(slice) }
3455 }
3456}
3457impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3458 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
3459 let mut iter = iter.into_iter();
3460 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
3461 }
3462}
3463impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3464 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
3465 let mut iter = iter.into_iter();
3466 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
3467 }
3468}
3469impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3470 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
3471 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
3472 let mut iter = iter.into_iter();
3473 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
3474 }
3475}
3476pub struct Tuple31Iter<'a, T>([&'a T; 31], Range<usize>);
3477impl<'a, T> Tuple31Iter<'a, T> {
3478 #[inline]
3479 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3480 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20, &t.21, &t.22, &t.23, &t.24, &t.25, &t.26, &t.27, &t.28, &t.29, &t.30], 0..31)
3481 }
3482}
3483impl<'a, T> Iterator for Tuple31Iter<'a, T> {
3484 type Item = &'a T;
3485 #[inline]
3486 fn next(&mut self) -> Option<Self::Item> {
3487 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3488 }
3489 #[inline]
3490 fn size_hint(&self) -> (usize, Option<usize>) {
3491 let len = self.len();
3492 (len, Some(len))
3493 }
3494 #[inline]
3495 fn count(self) -> usize {
3496 self.len()
3497 }
3498 #[inline]
3499 fn last(mut self) -> Option<Self::Item> {
3500 self.next_back()
3501 }
3502}
3503impl<'a, T> DoubleEndedIterator for Tuple31Iter<'a, T> {
3504 #[inline]
3505 fn next_back(&mut self) -> Option<Self::Item> {
3506 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3507 }
3508}
3509impl<'a, T> ExactSizeIterator for Tuple31Iter<'a, T> {
3510 #[inline]
3511 fn len(&self) -> usize {
3512 self.1.end - self.1.start
3513 }
3514}
3515impl<'a, T> FusedIterator for Tuple31Iter<'a, T> {}
3516impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3517 type Iter = Tuple31Iter<'a, T>;
3518 #[inline]
3519 fn iter(&'a self) -> Self::Iter {
3520 Tuple31Iter::new(self)
3521 }
3522}
3523pub struct Tuple31IntoIter<T>([MaybeUninit<T>; 31], Range<usize>);
3524impl<T> Tuple31IntoIter<T> {
3525 #[inline]
3526 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3527 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20), MaybeUninit::new(t.21), MaybeUninit::new(t.22), MaybeUninit::new(t.23), MaybeUninit::new(t.24), MaybeUninit::new(t.25), MaybeUninit::new(t.26), MaybeUninit::new(t.27), MaybeUninit::new(t.28), MaybeUninit::new(t.29), MaybeUninit::new(t.30)], 0..31)
3528 }
3529}
3530impl<T> Iterator for Tuple31IntoIter<T> {
3531 type Item = T;
3532 #[inline]
3533 fn next(&mut self) -> Option<Self::Item> {
3534 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3535 }
3536 #[inline]
3537 fn size_hint(&self) -> (usize, Option<usize>) {
3538 let len = self.len();
3539 (len, Some(len))
3540 }
3541 #[inline]
3542 fn count(self) -> usize {
3543 self.len()
3544 }
3545 #[inline]
3546 fn last(mut self) -> Option<Self::Item> {
3547 self.next_back()
3548 }
3549}
3550impl<T> DoubleEndedIterator for Tuple31IntoIter<T> {
3551 fn next_back(&mut self) -> Option<Self::Item> {
3552 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3553 }
3554}
3555impl<T> ExactSizeIterator for Tuple31IntoIter<T> {
3556 #[inline]
3557 fn len(&self) -> usize {
3558 self.1.end - self.1.start
3559 }
3560}
3561impl<T> FusedIterator for Tuple31IntoIter<T> {}
3562impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3563 type Iter = Tuple31IntoIter<T>;
3564 #[inline]
3565 fn into_iter(self) -> Self::Iter {
3566 Tuple31IntoIter::new(self)
3567 }
3568}
3569impl<T> Drop for Tuple31IntoIter<T> {
3570 fn drop(&mut self) {
3571 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
3572 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
3573 unsafe { core::ptr::drop_in_place(slice) }
3574 }
3575}
3576impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3577 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
3578 let mut iter = iter.into_iter();
3579 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
3580 }
3581}
3582impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3583 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
3584 let mut iter = iter.into_iter();
3585 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
3586 }
3587}
3588impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3589 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
3590 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
3591 let mut iter = iter.into_iter();
3592 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
3593 }
3594}
3595pub struct Tuple32Iter<'a, T>([&'a T; 32], Range<usize>);
3596impl<'a, T> Tuple32Iter<'a, T> {
3597 #[inline]
3598 pub fn new(t: &'a (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3599 Self([&t.0, &t.1, &t.2, &t.3, &t.4, &t.5, &t.6, &t.7, &t.8, &t.9, &t.10, &t.11, &t.12, &t.13, &t.14, &t.15, &t.16, &t.17, &t.18, &t.19, &t.20, &t.21, &t.22, &t.23, &t.24, &t.25, &t.26, &t.27, &t.28, &t.29, &t.30, &t.31], 0..32)
3600 }
3601}
3602impl<'a, T> Iterator for Tuple32Iter<'a, T> {
3603 type Item = &'a T;
3604 #[inline]
3605 fn next(&mut self) -> Option<Self::Item> {
3606 self.1.next().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3607 }
3608 #[inline]
3609 fn size_hint(&self) -> (usize, Option<usize>) {
3610 let len = self.len();
3611 (len, Some(len))
3612 }
3613 #[inline]
3614 fn count(self) -> usize {
3615 self.len()
3616 }
3617 #[inline]
3618 fn last(mut self) -> Option<Self::Item> {
3619 self.next_back()
3620 }
3621}
3622impl<'a, T> DoubleEndedIterator for Tuple32Iter<'a, T> {
3623 #[inline]
3624 fn next_back(&mut self) -> Option<Self::Item> {
3625 self.1.next_back().map(|idx| unsafe { *self.0.get_unchecked(idx) })
3626 }
3627}
3628impl<'a, T> ExactSizeIterator for Tuple32Iter<'a, T> {
3629 #[inline]
3630 fn len(&self) -> usize {
3631 self.1.end - self.1.start
3632 }
3633}
3634impl<'a, T> FusedIterator for Tuple32Iter<'a, T> {}
3635impl<'a, T: 'a> TupleIter<'a> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3636 type Iter = Tuple32Iter<'a, T>;
3637 #[inline]
3638 fn iter(&'a self) -> Self::Iter {
3639 Tuple32Iter::new(self)
3640 }
3641}
3642pub struct Tuple32IntoIter<T>([MaybeUninit<T>; 32], Range<usize>);
3643impl<T> Tuple32IntoIter<T> {
3644 #[inline]
3645 pub fn new(t: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self {
3646 Self([MaybeUninit::new(t.0), MaybeUninit::new(t.1), MaybeUninit::new(t.2), MaybeUninit::new(t.3), MaybeUninit::new(t.4), MaybeUninit::new(t.5), MaybeUninit::new(t.6), MaybeUninit::new(t.7), MaybeUninit::new(t.8), MaybeUninit::new(t.9), MaybeUninit::new(t.10), MaybeUninit::new(t.11), MaybeUninit::new(t.12), MaybeUninit::new(t.13), MaybeUninit::new(t.14), MaybeUninit::new(t.15), MaybeUninit::new(t.16), MaybeUninit::new(t.17), MaybeUninit::new(t.18), MaybeUninit::new(t.19), MaybeUninit::new(t.20), MaybeUninit::new(t.21), MaybeUninit::new(t.22), MaybeUninit::new(t.23), MaybeUninit::new(t.24), MaybeUninit::new(t.25), MaybeUninit::new(t.26), MaybeUninit::new(t.27), MaybeUninit::new(t.28), MaybeUninit::new(t.29), MaybeUninit::new(t.30), MaybeUninit::new(t.31)], 0..32)
3647 }
3648}
3649impl<T> Iterator for Tuple32IntoIter<T> {
3650 type Item = T;
3651 #[inline]
3652 fn next(&mut self) -> Option<Self::Item> {
3653 self.1.next().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3654 }
3655 #[inline]
3656 fn size_hint(&self) -> (usize, Option<usize>) {
3657 let len = self.len();
3658 (len, Some(len))
3659 }
3660 #[inline]
3661 fn count(self) -> usize {
3662 self.len()
3663 }
3664 #[inline]
3665 fn last(mut self) -> Option<Self::Item> {
3666 self.next_back()
3667 }
3668}
3669impl<T> DoubleEndedIterator for Tuple32IntoIter<T> {
3670 fn next_back(&mut self) -> Option<Self::Item> {
3671 self.1.next_back().map(|idx| unsafe { core::mem::replace(self.0.get_unchecked_mut(idx), MaybeUninit::uninit()).assume_init() })
3672 }
3673}
3674impl<T> ExactSizeIterator for Tuple32IntoIter<T> {
3675 #[inline]
3676 fn len(&self) -> usize {
3677 self.1.end - self.1.start
3678 }
3679}
3680impl<T> FusedIterator for Tuple32IntoIter<T> {}
3681impl<T> TupleIntoIter for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3682 type Iter = Tuple32IntoIter<T>;
3683 #[inline]
3684 fn into_iter(self) -> Self::Iter {
3685 Tuple32IntoIter::new(self)
3686 }
3687}
3688impl<T> Drop for Tuple32IntoIter<T> {
3689 fn drop(&mut self) {
3690 let slice = unsafe { self.0.get_unchecked_mut(self.1.clone()) };
3691 let slice = unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) };
3692 unsafe { core::ptr::drop_in_place(slice) }
3693 }
3694}
3695impl<T> TupleFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3696 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
3697 let mut iter = iter.into_iter();
3698 (iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap(), iter.next().unwrap())
3699 }
3700}
3701impl<T> TupleTryFromIter<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3702 fn try_from_iter<I: IntoIterator<Item = T>>(iter: I) -> Option<Self> {
3703 let mut iter = iter.into_iter();
3704 Some((iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?, iter.next()?))
3705 }
3706}
3707impl<T> TupleFromIterTry<T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {
3708 type OutTuple = (Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>, Option<T>);
3709 fn from_iter_try<I: IntoIterator<Item = T>>(iter: I) -> Self::OutTuple {
3710 let mut iter = iter.into_iter();
3711 (iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next(), iter.next())
3712 }
3713}