1use super::TrustedLen;
2
3/// Conversion from an [`Iterator`].
4///
5/// By implementing `FromIterator` for a type, you define how it will be
6/// created from an iterator. This is common for types which describe a
7/// collection of some kind.
8///
9/// If you want to create a collection from the contents of an iterator, the
10/// [`Iterator::collect()`] method is preferred. However, when you need to
11/// specify the container type, [`FromIterator::from_iter()`] can be more
12/// readable than using a turbofish (e.g. `::<Vec<_>>()`). See the
13/// [`Iterator::collect()`] documentation for more examples of its use.
14///
15/// See also: [`IntoIterator`].
16///
17/// # Examples
18///
19/// Basic usage:
20///
21/// ```
22/// let five_fives = std::iter::repeat(5).take(5);
23///
24/// let v = Vec::from_iter(five_fives);
25///
26/// assert_eq!(v, vec![5, 5, 5, 5, 5]);
27/// ```
28///
29/// Using [`Iterator::collect()`] to implicitly use `FromIterator`:
30///
31/// ```
32/// let five_fives = std::iter::repeat(5).take(5);
33///
34/// let v: Vec<i32> = five_fives.collect();
35///
36/// assert_eq!(v, vec![5, 5, 5, 5, 5]);
37/// ```
38///
39/// Using [`FromIterator::from_iter()`] as a more readable alternative to
40/// [`Iterator::collect()`]:
41///
42/// ```
43/// use std::collections::VecDeque;
44/// let first = (0..10).collect::<VecDeque<i32>>();
45/// let second = VecDeque::from_iter(0..10);
46///
47/// assert_eq!(first, second);
48/// ```
49///
50/// Implementing `FromIterator` for your type:
51///
52/// ```
53/// // A sample collection, that's just a wrapper over Vec<T>
54/// #[derive(Debug)]
55/// struct MyCollection(Vec<i32>);
56///
57/// // Let's give it some methods so we can create one and add things
58/// // to it.
59/// impl MyCollection {
60/// fn new() -> MyCollection {
61/// MyCollection(Vec::new())
62/// }
63///
64/// fn add(&mut self, elem: i32) {
65/// self.0.push(elem);
66/// }
67/// }
68///
69/// // and we'll implement FromIterator
70/// impl FromIterator<i32> for MyCollection {
71/// fn from_iter<I: IntoIterator<Item=i32>>(iter: I) -> Self {
72/// let mut c = MyCollection::new();
73///
74/// for i in iter {
75/// c.add(i);
76/// }
77///
78/// c
79/// }
80/// }
81///
82/// // Now we can make a new iterator...
83/// let iter = (0..5).into_iter();
84///
85/// // ... and make a MyCollection out of it
86/// let c = MyCollection::from_iter(iter);
87///
88/// assert_eq!(c.0, vec![0, 1, 2, 3, 4]);
89///
90/// // collect works too!
91///
92/// let iter = (0..5).into_iter();
93/// let c: MyCollection = iter.collect();
94///
95/// assert_eq!(c.0, vec![0, 1, 2, 3, 4]);
96/// ```
97#[stable(feature = "rust1", since = "1.0.0")]
98#[rustc_on_unimplemented(
99 on(
100 Self = "&[{A}]",
101 message = "a slice of type `{Self}` cannot be built since we need to store the elements somewhere",
102 label = "try explicitly collecting into a `Vec<{A}>`",
103 ),
104 on(
105 all(A = "{integer}", any(Self = "&[{integral}]",)),
106 message = "a slice of type `{Self}` cannot be built since we need to store the elements somewhere",
107 label = "try explicitly collecting into a `Vec<{A}>`",
108 ),
109 on(
110 Self = "[{A}]",
111 message = "a slice of type `{Self}` cannot be built since `{Self}` has no definite size",
112 label = "try explicitly collecting into a `Vec<{A}>`",
113 ),
114 on(
115 all(A = "{integer}", any(Self = "[{integral}]",)),
116 message = "a slice of type `{Self}` cannot be built since `{Self}` has no definite size",
117 label = "try explicitly collecting into a `Vec<{A}>`",
118 ),
119 on(
120 Self = "[{A}; _]",
121 message = "an array of type `{Self}` cannot be built directly from an iterator",
122 label = "try collecting into a `Vec<{A}>`, then using `.try_into()`",
123 ),
124 on(
125 all(A = "{integer}", any(Self = "[{integral}; _]",)),
126 message = "an array of type `{Self}` cannot be built directly from an iterator",
127 label = "try collecting into a `Vec<{A}>`, then using `.try_into()`",
128 ),
129 message = "a value of type `{Self}` cannot be built from an iterator \
130 over elements of type `{A}`",
131 label = "value of type `{Self}` cannot be built from `std::iter::Iterator<Item={A}>`"
132)]
133#[rustc_diagnostic_item = "FromIterator"]
134pub trait FromIterator<A>: Sized {
135 /// Creates a value from an iterator.
136 ///
137 /// See the [module-level documentation] for more.
138 ///
139 /// [module-level documentation]: crate::iter
140 ///
141 /// # Examples
142 ///
143 /// ```
144 /// let five_fives = std::iter::repeat(5).take(5);
145 ///
146 /// let v = Vec::from_iter(five_fives);
147 ///
148 /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
149 /// ```
150 #[stable(feature = "rust1", since = "1.0.0")]
151 #[rustc_diagnostic_item = "from_iter_fn"]
152 fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self;
153}
154
155/// Conversion into an [`Iterator`].
156///
157/// By implementing `IntoIterator` for a type, you define how it will be
158/// converted to an iterator. This is common for types which describe a
159/// collection of some kind.
160///
161/// One benefit of implementing `IntoIterator` is that your type will [work
162/// with Rust's `for` loop syntax](crate::iter#for-loops-and-intoiterator).
163///
164/// See also: [`FromIterator`].
165///
166/// # Examples
167///
168/// Basic usage:
169///
170/// ```
171/// let v = [1, 2, 3];
172/// let mut iter = v.into_iter();
173///
174/// assert_eq!(Some(1), iter.next());
175/// assert_eq!(Some(2), iter.next());
176/// assert_eq!(Some(3), iter.next());
177/// assert_eq!(None, iter.next());
178/// ```
179/// Implementing `IntoIterator` for your type:
180///
181/// ```
182/// // A sample collection, that's just a wrapper over Vec<T>
183/// #[derive(Debug)]
184/// struct MyCollection(Vec<i32>);
185///
186/// // Let's give it some methods so we can create one and add things
187/// // to it.
188/// impl MyCollection {
189/// fn new() -> MyCollection {
190/// MyCollection(Vec::new())
191/// }
192///
193/// fn add(&mut self, elem: i32) {
194/// self.0.push(elem);
195/// }
196/// }
197///
198/// // and we'll implement IntoIterator
199/// impl IntoIterator for MyCollection {
200/// type Item = i32;
201/// type IntoIter = std::vec::IntoIter<Self::Item>;
202///
203/// fn into_iter(self) -> Self::IntoIter {
204/// self.0.into_iter()
205/// }
206/// }
207///
208/// // Now we can make a new collection...
209/// let mut c = MyCollection::new();
210///
211/// // ... add some stuff to it ...
212/// c.add(0);
213/// c.add(1);
214/// c.add(2);
215///
216/// // ... and then turn it into an Iterator:
217/// for (i, n) in c.into_iter().enumerate() {
218/// assert_eq!(i as i32, n);
219/// }
220/// ```
221///
222/// It is common to use `IntoIterator` as a trait bound. This allows
223/// the input collection type to change, so long as it is still an
224/// iterator. Additional bounds can be specified by restricting on
225/// `Item`:
226///
227/// ```rust
228/// fn collect_as_strings<T>(collection: T) -> Vec<String>
229/// where
230/// T: IntoIterator,
231/// T::Item: std::fmt::Debug,
232/// {
233/// collection
234/// .into_iter()
235/// .map(|item| format!("{item:?}"))
236/// .collect()
237/// }
238/// ```
239#[rustc_diagnostic_item = "IntoIterator"]
240#[rustc_on_unimplemented(
241 on(
242 Self = "core::ops::range::RangeTo<Idx>",
243 label = "if you meant to iterate until a value, add a starting value",
244 note = "`..end` is a `RangeTo`, which cannot be iterated on; you might have meant to have a \
245 bounded `Range`: `0..end`"
246 ),
247 on(
248 Self = "core::ops::range::RangeToInclusive<Idx>",
249 label = "if you meant to iterate until a value (including it), add a starting value",
250 note = "`..=end` is a `RangeToInclusive`, which cannot be iterated on; you might have meant \
251 to have a bounded `RangeInclusive`: `0..=end`"
252 ),
253 on(
254 Self = "[]",
255 label = "`{Self}` is not an iterator; try calling `.into_iter()` or `.iter()`"
256 ),
257 on(Self = "&[]", label = "`{Self}` is not an iterator; try calling `.iter()`"),
258 on(
259 Self = "alloc::vec::Vec<T, A>",
260 label = "`{Self}` is not an iterator; try calling `.into_iter()` or `.iter()`"
261 ),
262 on(Self = "&str", label = "`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`"),
263 on(
264 Self = "alloc::string::String",
265 label = "`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`"
266 ),
267 on(
268 Self = "{integral}",
269 note = "if you want to iterate between `start` until a value `end`, use the exclusive range \
270 syntax `start..end` or the inclusive range syntax `start..=end`"
271 ),
272 on(
273 Self = "{float}",
274 note = "if you want to iterate between `start` until a value `end`, use the exclusive range \
275 syntax `start..end` or the inclusive range syntax `start..=end`"
276 ),
277 label = "`{Self}` is not an iterator",
278 message = "`{Self}` is not an iterator"
279)]
280#[rustc_skip_during_method_dispatch(array, boxed_slice)]
281#[stable(feature = "rust1", since = "1.0.0")]
282pub trait IntoIterator {
283 /// The type of the elements being iterated over.
284 #[stable(feature = "rust1", since = "1.0.0")]
285 type Item;
286
287 /// Which kind of iterator are we turning this into?
288 #[stable(feature = "rust1", since = "1.0.0")]
289 type IntoIter: Iterator<Item = Self::Item>;
290
291 /// Creates an iterator from a value.
292 ///
293 /// See the [module-level documentation] for more.
294 ///
295 /// [module-level documentation]: crate::iter
296 ///
297 /// # Examples
298 ///
299 /// ```
300 /// let v = [1, 2, 3];
301 /// let mut iter = v.into_iter();
302 ///
303 /// assert_eq!(Some(1), iter.next());
304 /// assert_eq!(Some(2), iter.next());
305 /// assert_eq!(Some(3), iter.next());
306 /// assert_eq!(None, iter.next());
307 /// ```
308 #[lang = "into_iter"]
309 #[stable(feature = "rust1", since = "1.0.0")]
310 fn into_iter(self) -> Self::IntoIter;
311}
312
313#[stable(feature = "rust1", since = "1.0.0")]
314impl<I: Iterator> IntoIterator for I {
315 type Item = I::Item;
316 type IntoIter = I;
317
318 #[inline]
319 fn into_iter(self) -> I {
320 self
321 }
322}
323
324/// Extend a collection with the contents of an iterator.
325///
326/// Iterators produce a series of values, and collections can also be thought
327/// of as a series of values. The `Extend` trait bridges this gap, allowing you
328/// to extend a collection by including the contents of that iterator. When
329/// extending a collection with an already existing key, that entry is updated
330/// or, in the case of collections that permit multiple entries with equal
331/// keys, that entry is inserted.
332///
333/// # Examples
334///
335/// Basic usage:
336///
337/// ```
338/// // You can extend a String with some chars:
339/// let mut message = String::from("The first three letters are: ");
340///
341/// message.extend(&['a', 'b', 'c']);
342///
343/// assert_eq!("abc", &message[29..32]);
344/// ```
345///
346/// Implementing `Extend`:
347///
348/// ```
349/// // A sample collection, that's just a wrapper over Vec<T>
350/// #[derive(Debug)]
351/// struct MyCollection(Vec<i32>);
352///
353/// // Let's give it some methods so we can create one and add things
354/// // to it.
355/// impl MyCollection {
356/// fn new() -> MyCollection {
357/// MyCollection(Vec::new())
358/// }
359///
360/// fn add(&mut self, elem: i32) {
361/// self.0.push(elem);
362/// }
363/// }
364///
365/// // since MyCollection has a list of i32s, we implement Extend for i32
366/// impl Extend<i32> for MyCollection {
367///
368/// // This is a bit simpler with the concrete type signature: we can call
369/// // extend on anything which can be turned into an Iterator which gives
370/// // us i32s. Because we need i32s to put into MyCollection.
371/// fn extend<T: IntoIterator<Item=i32>>(&mut self, iter: T) {
372///
373/// // The implementation is very straightforward: loop through the
374/// // iterator, and add() each element to ourselves.
375/// for elem in iter {
376/// self.add(elem);
377/// }
378/// }
379/// }
380///
381/// let mut c = MyCollection::new();
382///
383/// c.add(5);
384/// c.add(6);
385/// c.add(7);
386///
387/// // let's extend our collection with three more numbers
388/// c.extend(vec![1, 2, 3]);
389///
390/// // we've added these elements onto the end
391/// assert_eq!("MyCollection([5, 6, 7, 1, 2, 3])", format!("{c:?}"));
392/// ```
393#[stable(feature = "rust1", since = "1.0.0")]
394pub trait Extend<A> {
395 /// Extends a collection with the contents of an iterator.
396 ///
397 /// As this is the only required method for this trait, the [trait-level] docs
398 /// contain more details.
399 ///
400 /// [trait-level]: Extend
401 ///
402 /// # Examples
403 ///
404 /// ```
405 /// // You can extend a String with some chars:
406 /// let mut message = String::from("abc");
407 ///
408 /// message.extend(['d', 'e', 'f'].iter());
409 ///
410 /// assert_eq!("abcdef", &message);
411 /// ```
412 #[stable(feature = "rust1", since = "1.0.0")]
413 fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T);
414
415 /// Extends a collection with exactly one element.
416 #[unstable(feature = "extend_one", issue = "72631")]
417 fn extend_one(&mut self, item: A) {
418 self.extend(Some(item));
419 }
420
421 /// Reserves capacity in a collection for the given number of additional elements.
422 ///
423 /// The default implementation does nothing.
424 #[unstable(feature = "extend_one", issue = "72631")]
425 fn extend_reserve(&mut self, additional: usize) {
426 let _ = additional;
427 }
428
429 /// Extends a collection with one element, without checking there is enough capacity for it.
430 ///
431 /// # Safety
432 ///
433 /// **For callers:** This must only be called when we know the collection has enough capacity
434 /// to contain the new item, for example because we previously called `extend_reserve`.
435 ///
436 /// **For implementors:** For a collection to unsafely rely on this method's safety precondition (that is,
437 /// invoke UB if they are violated), it must implement `extend_reserve` correctly. In other words,
438 /// callers may assume that if they `extend_reserve`ed enough space they can call this method.
439
440 // This method is for internal usage only. It is only on the trait because of specialization's limitations.
441 #[unstable(feature = "extend_one_unchecked", issue = "none")]
442 #[doc(hidden)]
443 unsafe fn extend_one_unchecked(&mut self, item: A)
444 where
445 Self: Sized,
446 {
447 self.extend_one(item);
448 }
449}
450
451#[stable(feature = "extend_for_unit", since = "1.28.0")]
452impl Extend<()> for () {
453 fn extend<T: IntoIterator<Item = ()>>(&mut self, iter: T) {
454 iter.into_iter().for_each(drop)
455 }
456 fn extend_one(&mut self, _item: ()) {}
457}
458
459macro_rules! spec_tuple_impl {
460 (
461 (
462 $ty_name:ident, $var_name:ident, $extend_ty_name: ident,
463 $trait_name:ident, $default_fn_name:ident, $cnt:tt
464 ),
465 ) => {
466 spec_tuple_impl!(
467 $trait_name,
468 $default_fn_name,
469 #[doc(fake_variadic)]
470 #[doc = "This trait is implemented for tuples up to twelve items long. The `impl`s for \
471 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in \
472 1.85.0."]
473 => ($ty_name, $var_name, $extend_ty_name, $cnt),
474 );
475 };
476 (
477 (
478 $ty_name:ident, $var_name:ident, $extend_ty_name: ident,
479 $trait_name:ident, $default_fn_name:ident, $cnt:tt
480 ),
481 $(
482 (
483 $ty_names:ident, $var_names:ident, $extend_ty_names:ident,
484 $trait_names:ident, $default_fn_names:ident, $cnts:tt
485 ),
486 )*
487 ) => {
488 spec_tuple_impl!(
489 $(
490 (
491 $ty_names, $var_names, $extend_ty_names,
492 $trait_names, $default_fn_names, $cnts
493 ),
494 )*
495 );
496 spec_tuple_impl!(
497 $trait_name,
498 $default_fn_name,
499 #[doc(hidden)]
500 => (
501 $ty_name, $var_name, $extend_ty_name, $cnt
502 ),
503 $(
504 (
505 $ty_names, $var_names, $extend_ty_names, $cnts
506 ),
507 )*
508 );
509 };
510 (
511 $trait_name:ident, $default_fn_name:ident, #[$meta:meta]
512 $(#[$doctext:meta])? => $(
513 (
514 $ty_names:ident, $var_names:ident, $extend_ty_names:ident, $cnts:tt
515 ),
516 )*
517 ) => {
518 #[$meta]
519 $(#[$doctext])?
520 #[stable(feature = "extend_for_tuple", since = "1.56.0")]
521 impl<$($ty_names,)* $($extend_ty_names,)*> Extend<($($ty_names,)*)> for ($($extend_ty_names,)*)
522 where
523 $($extend_ty_names: Extend<$ty_names>,)*
524 {
525 /// Allows to `extend` a tuple of collections that also implement `Extend`.
526 ///
527 /// See also: [`Iterator::unzip`]
528 ///
529 /// # Examples
530 /// ```
531 /// // Example given for a 2-tuple, but 1- through 12-tuples are supported
532 /// let mut tuple = (vec![0], vec![1]);
533 /// tuple.extend([(2, 3), (4, 5), (6, 7)]);
534 /// assert_eq!(tuple.0, [0, 2, 4, 6]);
535 /// assert_eq!(tuple.1, [1, 3, 5, 7]);
536 ///
537 /// // also allows for arbitrarily nested tuples as elements
538 /// let mut nested_tuple = (vec![1], (vec![2], vec![3]));
539 /// nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);
540 ///
541 /// let (a, (b, c)) = nested_tuple;
542 /// assert_eq!(a, [1, 4, 7]);
543 /// assert_eq!(b, [2, 5, 8]);
544 /// assert_eq!(c, [3, 6, 9]);
545 /// ```
546 fn extend<T: IntoIterator<Item = ($($ty_names,)*)>>(&mut self, into_iter: T) {
547 let ($($var_names,)*) = self;
548 let iter = into_iter.into_iter();
549 $trait_name::extend(iter, $($var_names,)*);
550 }
551
552 fn extend_one(&mut self, item: ($($ty_names,)*)) {
553 $(self.$cnts.extend_one(item.$cnts);)*
554 }
555
556 fn extend_reserve(&mut self, additional: usize) {
557 $(self.$cnts.extend_reserve(additional);)*
558 }
559
560 unsafe fn extend_one_unchecked(&mut self, item: ($($ty_names,)*)) {
561 // SAFETY: Those are our safety preconditions, and we correctly forward `extend_reserve`.
562 unsafe {
563 $(self.$cnts.extend_one_unchecked(item.$cnts);)*
564 }
565 }
566 }
567
568 trait $trait_name<$($ty_names),*> {
569 fn extend(self, $($var_names: &mut $ty_names,)*);
570 }
571
572 fn $default_fn_name<$($ty_names,)* $($extend_ty_names,)*>(
573 iter: impl Iterator<Item = ($($ty_names,)*)>,
574 $($var_names: &mut $extend_ty_names,)*
575 ) where
576 $($extend_ty_names: Extend<$ty_names>,)*
577 {
578 fn extend<'a, $($ty_names,)*>(
579 $($var_names: &'a mut impl Extend<$ty_names>,)*
580 ) -> impl FnMut((), ($($ty_names,)*)) + 'a {
581 #[allow(non_snake_case)]
582 move |(), ($($extend_ty_names,)*)| {
583 $($var_names.extend_one($extend_ty_names);)*
584 }
585 }
586
587 let (lower_bound, _) = iter.size_hint();
588 if lower_bound > 0 {
589 $($var_names.extend_reserve(lower_bound);)*
590 }
591
592 iter.fold((), extend($($var_names,)*));
593 }
594
595 impl<$($ty_names,)* $($extend_ty_names,)* Iter> $trait_name<$($extend_ty_names),*> for Iter
596 where
597 $($extend_ty_names: Extend<$ty_names>,)*
598 Iter: Iterator<Item = ($($ty_names,)*)>,
599 {
600 default fn extend(self, $($var_names: &mut $extend_ty_names),*) {
601 $default_fn_name(self, $($var_names),*);
602 }
603 }
604
605 impl<$($ty_names,)* $($extend_ty_names,)* Iter> $trait_name<$($extend_ty_names),*> for Iter
606 where
607 $($extend_ty_names: Extend<$ty_names>,)*
608 Iter: TrustedLen<Item = ($($ty_names,)*)>,
609 {
610 fn extend(self, $($var_names: &mut $extend_ty_names,)*) {
611 fn extend<'a, $($ty_names,)*>(
612 $($var_names: &'a mut impl Extend<$ty_names>,)*
613 ) -> impl FnMut((), ($($ty_names,)*)) + 'a {
614 #[allow(non_snake_case)]
615 // SAFETY: We reserve enough space for the `size_hint`, and the iterator is
616 // `TrustedLen` so its `size_hint` is exact.
617 move |(), ($($extend_ty_names,)*)| unsafe {
618 $($var_names.extend_one_unchecked($extend_ty_names);)*
619 }
620 }
621
622 let (lower_bound, upper_bound) = self.size_hint();
623
624 if upper_bound.is_none() {
625 // We cannot reserve more than `usize::MAX` items, and this is likely to go out of memory anyway.
626 $default_fn_name(self, $($var_names,)*);
627 return;
628 }
629
630 if lower_bound > 0 {
631 $($var_names.extend_reserve(lower_bound);)*
632 }
633
634 self.fold((), extend($($var_names,)*));
635 }
636 }
637
638 /// This implementation turns an iterator of tuples into a tuple of types which implement
639 /// [`Default`] and [`Extend`].
640 ///
641 /// This is similar to [`Iterator::unzip`], but is also composable with other [`FromIterator`]
642 /// implementations:
643 ///
644 /// ```rust
645 /// # fn main() -> Result<(), core::num::ParseIntError> {
646 /// let string = "1,2,123,4";
647 ///
648 /// // Example given for a 2-tuple, but 1- through 12-tuples are supported
649 /// let (numbers, lengths): (Vec<_>, Vec<_>) = string
650 /// .split(',')
651 /// .map(|s| s.parse().map(|n: u32| (n, s.len())))
652 /// .collect::<Result<_, _>>()?;
653 ///
654 /// assert_eq!(numbers, [1, 2, 123, 4]);
655 /// assert_eq!(lengths, [1, 1, 3, 1]);
656 /// # Ok(()) }
657 /// ```
658 #[$meta]
659 $(#[$doctext])?
660 #[stable(feature = "from_iterator_for_tuple", since = "1.79.0")]
661 impl<$($ty_names,)* $($extend_ty_names,)*> FromIterator<($($extend_ty_names,)*)> for ($($ty_names,)*)
662 where
663 $($ty_names: Default + Extend<$extend_ty_names>,)*
664 {
665 fn from_iter<Iter: IntoIterator<Item = ($($extend_ty_names,)*)>>(iter: Iter) -> Self {
666 let mut res = <($($ty_names,)*)>::default();
667 res.extend(iter);
668
669 res
670 }
671 }
672
673 };
674}
675
676spec_tuple_impl!(
677 (L, l, EL, TraitL, default_extend_tuple_l, 11),
678 (K, k, EK, TraitK, default_extend_tuple_k, 10),
679 (J, j, EJ, TraitJ, default_extend_tuple_j, 9),
680 (I, i, EI, TraitI, default_extend_tuple_i, 8),
681 (H, h, EH, TraitH, default_extend_tuple_h, 7),
682 (G, g, EG, TraitG, default_extend_tuple_g, 6),
683 (F, f, EF, TraitF, default_extend_tuple_f, 5),
684 (E, e, EE, TraitE, default_extend_tuple_e, 4),
685 (D, d, ED, TraitD, default_extend_tuple_d, 3),
686 (C, c, EC, TraitC, default_extend_tuple_c, 2),
687 (B, b, EB, TraitB, default_extend_tuple_b, 1),
688 (A, a, EA, TraitA, default_extend_tuple_a, 0),
689);
690