core/iter/traits/collect.rs
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 // This method is for internal usage only. It is only on the trait because of specialization's limitations.
440 #[unstable(feature = "extend_one_unchecked", issue = "none")]
441 #[doc(hidden)]
442 unsafe fn extend_one_unchecked(&mut self, item: A)
443 where
444 Self: Sized,
445 {
446 self.extend_one(item);
447 }
448}
449
450#[stable(feature = "extend_for_unit", since = "1.28.0")]
451impl Extend<()> for () {
452 fn extend<T: IntoIterator<Item = ()>>(&mut self, iter: T) {
453 iter.into_iter().for_each(drop)
454 }
455 fn extend_one(&mut self, _item: ()) {}
456}
457
458macro_rules! spec_tuple_impl {
459 (
460 (
461 $ty_name:ident, $var_name:ident, $extend_ty_name: ident,
462 $trait_name:ident, $default_fn_name:ident, $cnt:tt
463 ),
464 ) => {
465 spec_tuple_impl!(
466 $trait_name,
467 $default_fn_name,
468 #[doc(fake_variadic)]
469 #[doc = "This trait is implemented for tuples up to twelve items long. The `impl`s for \
470 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in \
471 1.85.0."]
472 => ($ty_name, $var_name, $extend_ty_name, $cnt),
473 );
474 };
475 (
476 (
477 $ty_name:ident, $var_name:ident, $extend_ty_name: ident,
478 $trait_name:ident, $default_fn_name:ident, $cnt:tt
479 ),
480 $(
481 (
482 $ty_names:ident, $var_names:ident, $extend_ty_names:ident,
483 $trait_names:ident, $default_fn_names:ident, $cnts:tt
484 ),
485 )*
486 ) => {
487 spec_tuple_impl!(
488 $(
489 (
490 $ty_names, $var_names, $extend_ty_names,
491 $trait_names, $default_fn_names, $cnts
492 ),
493 )*
494 );
495 spec_tuple_impl!(
496 $trait_name,
497 $default_fn_name,
498 #[doc(hidden)]
499 => (
500 $ty_name, $var_name, $extend_ty_name, $cnt
501 ),
502 $(
503 (
504 $ty_names, $var_names, $extend_ty_names, $cnts
505 ),
506 )*
507 );
508 };
509 (
510 $trait_name:ident, $default_fn_name:ident, #[$meta:meta]
511 $(#[$doctext:meta])? => $(
512 (
513 $ty_names:ident, $var_names:ident, $extend_ty_names:ident, $cnts:tt
514 ),
515 )*
516 ) => {
517 #[$meta]
518 $(#[$doctext])?
519 #[stable(feature = "extend_for_tuple", since = "1.56.0")]
520 impl<$($ty_names,)* $($extend_ty_names,)*> Extend<($($ty_names,)*)> for ($($extend_ty_names,)*)
521 where
522 $($extend_ty_names: Extend<$ty_names>,)*
523 {
524 /// Allows to `extend` a tuple of collections that also implement `Extend`.
525 ///
526 /// See also: [`Iterator::unzip`]
527 ///
528 /// # Examples
529 /// ```
530 /// // Example given for a 2-tuple, but 1- through 12-tuples are supported
531 /// let mut tuple = (vec![0], vec![1]);
532 /// tuple.extend([(2, 3), (4, 5), (6, 7)]);
533 /// assert_eq!(tuple.0, [0, 2, 4, 6]);
534 /// assert_eq!(tuple.1, [1, 3, 5, 7]);
535 ///
536 /// // also allows for arbitrarily nested tuples as elements
537 /// let mut nested_tuple = (vec![1], (vec![2], vec![3]));
538 /// nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);
539 ///
540 /// let (a, (b, c)) = nested_tuple;
541 /// assert_eq!(a, [1, 4, 7]);
542 /// assert_eq!(b, [2, 5, 8]);
543 /// assert_eq!(c, [3, 6, 9]);
544 /// ```
545 fn extend<T: IntoIterator<Item = ($($ty_names,)*)>>(&mut self, into_iter: T) {
546 let ($($var_names,)*) = self;
547 let iter = into_iter.into_iter();
548 $trait_name::extend(iter, $($var_names,)*);
549 }
550
551 fn extend_one(&mut self, item: ($($ty_names,)*)) {
552 $(self.$cnts.extend_one(item.$cnts);)*
553 }
554
555 fn extend_reserve(&mut self, additional: usize) {
556 $(self.$cnts.extend_reserve(additional);)*
557 }
558
559 unsafe fn extend_one_unchecked(&mut self, item: ($($ty_names,)*)) {
560 // SAFETY: Those are our safety preconditions, and we correctly forward `extend_reserve`.
561 unsafe {
562 $(self.$cnts.extend_one_unchecked(item.$cnts);)*
563 }
564 }
565 }
566
567 trait $trait_name<$($ty_names),*> {
568 fn extend(self, $($var_names: &mut $ty_names,)*);
569 }
570
571 fn $default_fn_name<$($ty_names,)* $($extend_ty_names,)*>(
572 iter: impl Iterator<Item = ($($ty_names,)*)>,
573 $($var_names: &mut $extend_ty_names,)*
574 ) where
575 $($extend_ty_names: Extend<$ty_names>,)*
576 {
577 fn extend<'a, $($ty_names,)*>(
578 $($var_names: &'a mut impl Extend<$ty_names>,)*
579 ) -> impl FnMut((), ($($ty_names,)*)) + 'a {
580 #[allow(non_snake_case)]
581 move |(), ($($extend_ty_names,)*)| {
582 $($var_names.extend_one($extend_ty_names);)*
583 }
584 }
585
586 let (lower_bound, _) = iter.size_hint();
587 if lower_bound > 0 {
588 $($var_names.extend_reserve(lower_bound);)*
589 }
590
591 iter.fold((), extend($($var_names,)*));
592 }
593
594 impl<$($ty_names,)* $($extend_ty_names,)* Iter> $trait_name<$($extend_ty_names),*> for Iter
595 where
596 $($extend_ty_names: Extend<$ty_names>,)*
597 Iter: Iterator<Item = ($($ty_names,)*)>,
598 {
599 default fn extend(self, $($var_names: &mut $extend_ty_names),*) {
600 $default_fn_name(self, $($var_names),*);
601 }
602 }
603
604 impl<$($ty_names,)* $($extend_ty_names,)* Iter> $trait_name<$($extend_ty_names),*> for Iter
605 where
606 $($extend_ty_names: Extend<$ty_names>,)*
607 Iter: TrustedLen<Item = ($($ty_names,)*)>,
608 {
609 fn extend(self, $($var_names: &mut $extend_ty_names,)*) {
610 fn extend<'a, $($ty_names,)*>(
611 $($var_names: &'a mut impl Extend<$ty_names>,)*
612 ) -> impl FnMut((), ($($ty_names,)*)) + 'a {
613 #[allow(non_snake_case)]
614 // SAFETY: We reserve enough space for the `size_hint`, and the iterator is
615 // `TrustedLen` so its `size_hint` is exact.
616 move |(), ($($extend_ty_names,)*)| unsafe {
617 $($var_names.extend_one_unchecked($extend_ty_names);)*
618 }
619 }
620
621 let (lower_bound, upper_bound) = self.size_hint();
622
623 if upper_bound.is_none() {
624 // We cannot reserve more than `usize::MAX` items, and this is likely to go out of memory anyway.
625 $default_fn_name(self, $($var_names,)*);
626 return;
627 }
628
629 if lower_bound > 0 {
630 $($var_names.extend_reserve(lower_bound);)*
631 }
632
633 self.fold((), extend($($var_names,)*));
634 }
635 }
636
637 /// This implementation turns an iterator of tuples into a tuple of types which implement
638 /// [`Default`] and [`Extend`].
639 ///
640 /// This is similar to [`Iterator::unzip`], but is also composable with other [`FromIterator`]
641 /// implementations:
642 ///
643 /// ```rust
644 /// # fn main() -> Result<(), core::num::ParseIntError> {
645 /// let string = "1,2,123,4";
646 ///
647 /// // Example given for a 2-tuple, but 1- through 12-tuples are supported
648 /// let (numbers, lengths): (Vec<_>, Vec<_>) = string
649 /// .split(',')
650 /// .map(|s| s.parse().map(|n: u32| (n, s.len())))
651 /// .collect::<Result<_, _>>()?;
652 ///
653 /// assert_eq!(numbers, [1, 2, 123, 4]);
654 /// assert_eq!(lengths, [1, 1, 3, 1]);
655 /// # Ok(()) }
656 /// ```
657 #[$meta]
658 $(#[$doctext])?
659 #[stable(feature = "from_iterator_for_tuple", since = "1.79.0")]
660 impl<$($ty_names,)* $($extend_ty_names,)*> FromIterator<($($extend_ty_names,)*)> for ($($ty_names,)*)
661 where
662 $($ty_names: Default + Extend<$extend_ty_names>,)*
663 {
664 fn from_iter<Iter: IntoIterator<Item = ($($extend_ty_names,)*)>>(iter: Iter) -> Self {
665 let mut res = <($($ty_names,)*)>::default();
666 res.extend(iter);
667
668 res
669 }
670 }
671
672 };
673}
674
675spec_tuple_impl!(
676 (L, l, EL, TraitL, default_extend_tuple_l, 11),
677 (K, k, EK, TraitK, default_extend_tuple_k, 10),
678 (J, j, EJ, TraitJ, default_extend_tuple_j, 9),
679 (I, i, EI, TraitI, default_extend_tuple_i, 8),
680 (H, h, EH, TraitH, default_extend_tuple_h, 7),
681 (G, g, EG, TraitG, default_extend_tuple_g, 6),
682 (F, f, EF, TraitF, default_extend_tuple_f, 5),
683 (E, e, EE, TraitE, default_extend_tuple_e, 4),
684 (D, d, ED, TraitD, default_extend_tuple_d, 3),
685 (C, c, EC, TraitC, default_extend_tuple_c, 2),
686 (B, b, EB, TraitB, default_extend_tuple_b, 1),
687 (A, a, EA, TraitA, default_extend_tuple_a, 0),
688);