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")]
282#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
283pub const trait IntoIterator {
284    /// The type of the elements being iterated over.
285    #[rustc_diagnostic_item = "IntoIteratorItem"]
286    #[stable(feature = "rust1", since = "1.0.0")]
287    type Item;
288
289    /// Which kind of iterator are we turning this into?
290    #[stable(feature = "rust1", since = "1.0.0")]
291    type IntoIter: Iterator<Item = Self::Item>;
292
293    /// Creates an iterator from a value.
294    ///
295    /// See the [module-level documentation] for more.
296    ///
297    /// [module-level documentation]: crate::iter
298    ///
299    /// # Examples
300    ///
301    /// ```
302    /// let v = [1, 2, 3];
303    /// let mut iter = v.into_iter();
304    ///
305    /// assert_eq!(Some(1), iter.next());
306    /// assert_eq!(Some(2), iter.next());
307    /// assert_eq!(Some(3), iter.next());
308    /// assert_eq!(None, iter.next());
309    /// ```
310    #[lang = "into_iter"]
311    #[stable(feature = "rust1", since = "1.0.0")]
312    fn into_iter(self) -> Self::IntoIter;
313}
314
315#[stable(feature = "rust1", since = "1.0.0")]
316#[rustc_const_unstable(feature = "const_iter", issue = "92476")]
317impl<I: [const] Iterator> const IntoIterator for I {
318    type Item = I::Item;
319    type IntoIter = I;
320
321    #[inline]
322    #[ferrocene::prevalidated]
323    fn into_iter(self) -> I {
324        self
325    }
326}
327
328/// Extend a collection with the contents of an iterator.
329///
330/// Iterators produce a series of values, and collections can also be thought
331/// of as a series of values. The `Extend` trait bridges this gap, allowing you
332/// to extend a collection by including the contents of that iterator. When
333/// extending a collection with an already existing key, that entry is updated
334/// or, in the case of collections that permit multiple entries with equal
335/// keys, that entry is inserted.
336///
337/// # Examples
338///
339/// Basic usage:
340///
341/// ```
342/// // You can extend a String with some chars:
343/// let mut message = String::from("The first three letters are: ");
344///
345/// message.extend(&['a', 'b', 'c']);
346///
347/// assert_eq!("abc", &message[29..32]);
348/// ```
349///
350/// Implementing `Extend`:
351///
352/// ```
353/// // A sample collection, that's just a wrapper over Vec<T>
354/// #[derive(Debug)]
355/// struct MyCollection(Vec<i32>);
356///
357/// // Let's give it some methods so we can create one and add things
358/// // to it.
359/// impl MyCollection {
360///     fn new() -> MyCollection {
361///         MyCollection(Vec::new())
362///     }
363///
364///     fn add(&mut self, elem: i32) {
365///         self.0.push(elem);
366///     }
367/// }
368///
369/// // since MyCollection has a list of i32s, we implement Extend for i32
370/// impl Extend<i32> for MyCollection {
371///
372///     // This is a bit simpler with the concrete type signature: we can call
373///     // extend on anything which can be turned into an Iterator which gives
374///     // us i32s. Because we need i32s to put into MyCollection.
375///     fn extend<T: IntoIterator<Item=i32>>(&mut self, iter: T) {
376///
377///         // The implementation is very straightforward: loop through the
378///         // iterator, and add() each element to ourselves.
379///         for elem in iter {
380///             self.add(elem);
381///         }
382///     }
383/// }
384///
385/// let mut c = MyCollection::new();
386///
387/// c.add(5);
388/// c.add(6);
389/// c.add(7);
390///
391/// // let's extend our collection with three more numbers
392/// c.extend(vec![1, 2, 3]);
393///
394/// // we've added these elements onto the end
395/// assert_eq!("MyCollection([5, 6, 7, 1, 2, 3])", format!("{c:?}"));
396/// ```
397#[stable(feature = "rust1", since = "1.0.0")]
398pub trait Extend<A> {
399    /// Extends a collection with the contents of an iterator.
400    ///
401    /// As this is the only required method for this trait, the [trait-level] docs
402    /// contain more details.
403    ///
404    /// [trait-level]: Extend
405    ///
406    /// # Examples
407    ///
408    /// ```
409    /// // You can extend a String with some chars:
410    /// let mut message = String::from("abc");
411    ///
412    /// message.extend(['d', 'e', 'f'].iter());
413    ///
414    /// assert_eq!("abcdef", &message);
415    /// ```
416    #[stable(feature = "rust1", since = "1.0.0")]
417    fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T);
418
419    /// Extends a collection with exactly one element.
420    #[unstable(feature = "extend_one", issue = "72631")]
421    #[ferrocene::prevalidated]
422    fn extend_one(&mut self, item: A) {
423        self.extend(Some(item));
424    }
425
426    /// Reserves capacity in a collection for the given number of additional elements.
427    ///
428    /// The default implementation does nothing.
429    #[unstable(feature = "extend_one", issue = "72631")]
430    #[ferrocene::prevalidated]
431    fn extend_reserve(&mut self, additional: usize) {
432        let _ = additional;
433    }
434
435    /// Extends a collection with one element, without checking there is enough capacity for it.
436    ///
437    /// # Safety
438    ///
439    /// **For callers:** This must only be called when we know the collection has enough capacity
440    /// to contain the new item, for example because we previously called `extend_reserve`.
441    ///
442    /// **For implementors:** For a collection to unsafely rely on this method's safety precondition (that is,
443    /// invoke UB if they are violated), it must implement `extend_reserve` correctly. In other words,
444    /// callers may assume that if they `extend_reserve`ed enough space they can call this method.
445    // This method is for internal usage only. It is only on the trait because of specialization's limitations.
446    #[unstable(feature = "extend_one_unchecked", issue = "none")]
447    #[doc(hidden)]
448    #[ferrocene::prevalidated]
449    unsafe fn extend_one_unchecked(&mut self, item: A)
450    where
451        Self: Sized,
452    {
453        self.extend_one(item);
454    }
455}
456
457#[stable(feature = "extend_for_unit", since = "1.28.0")]
458impl Extend<()> for () {
459    fn extend<T: IntoIterator<Item = ()>>(&mut self, iter: T) {
460        iter.into_iter().for_each(drop)
461    }
462    fn extend_one(&mut self, _item: ()) {}
463}
464
465/// This trait is implemented for tuples up to twelve items long. The `impl`s for
466/// 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in 1.85.0.
467#[doc(fake_variadic)] // the other implementations are below.
468#[stable(feature = "extend_for_tuple", since = "1.56.0")]
469impl<T, ExtendT> Extend<(T,)> for (ExtendT,)
470where
471    ExtendT: Extend<T>,
472{
473    /// Allows to `extend` a tuple of collections that also implement `Extend`.
474    ///
475    /// See also: [`Iterator::unzip`]
476    ///
477    /// # Examples
478    /// ```
479    /// // Example given for a 2-tuple, but 1- through 12-tuples are supported
480    /// let mut tuple = (vec![0], vec![1]);
481    /// tuple.extend([(2, 3), (4, 5), (6, 7)]);
482    /// assert_eq!(tuple.0, [0, 2, 4, 6]);
483    /// assert_eq!(tuple.1, [1, 3, 5, 7]);
484    ///
485    /// // also allows for arbitrarily nested tuples as elements
486    /// let mut nested_tuple = (vec![1], (vec![2], vec![3]));
487    /// nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);
488    ///
489    /// let (a, (b, c)) = nested_tuple;
490    /// assert_eq!(a, [1, 4, 7]);
491    /// assert_eq!(b, [2, 5, 8]);
492    /// assert_eq!(c, [3, 6, 9]);
493    /// ```
494    fn extend<I: IntoIterator<Item = (T,)>>(&mut self, iter: I) {
495        self.0.extend(iter.into_iter().map(|t| t.0));
496    }
497
498    fn extend_one(&mut self, item: (T,)) {
499        self.0.extend_one(item.0)
500    }
501
502    fn extend_reserve(&mut self, additional: usize) {
503        self.0.extend_reserve(additional)
504    }
505
506    unsafe fn extend_one_unchecked(&mut self, item: (T,)) {
507        // SAFETY: the caller guarantees all preconditions.
508        unsafe { self.0.extend_one_unchecked(item.0) }
509    }
510}
511
512/// This implementation turns an iterator of tuples into a tuple of types which implement
513/// [`Default`] and [`Extend`].
514///
515/// This is similar to [`Iterator::unzip`], but is also composable with other [`FromIterator`]
516/// implementations:
517///
518/// ```rust
519/// # fn main() -> Result<(), core::num::ParseIntError> {
520/// let string = "1,2,123,4";
521///
522/// // Example given for a 2-tuple, but 1- through 12-tuples are supported
523/// let (numbers, lengths): (Vec<_>, Vec<_>) = string
524///     .split(',')
525///     .map(|s| s.parse().map(|n: u32| (n, s.len())))
526///     .collect::<Result<_, _>>()?;
527///
528/// assert_eq!(numbers, [1, 2, 123, 4]);
529/// assert_eq!(lengths, [1, 1, 3, 1]);
530/// # Ok(()) }
531/// ```
532#[doc(fake_variadic)] // the other implementations are below.
533#[stable(feature = "from_iterator_for_tuple", since = "1.79.0")]
534impl<T, ExtendT> FromIterator<(T,)> for (ExtendT,)
535where
536    ExtendT: Default + Extend<T>,
537{
538    fn from_iter<Iter: IntoIterator<Item = (T,)>>(iter: Iter) -> Self {
539        let mut res = ExtendT::default();
540        res.extend(iter.into_iter().map(|t| t.0));
541        (res,)
542    }
543}
544
545/// An implementation of [`extend`](Extend::extend) that calls `extend_one` or
546/// `extend_one_unchecked` for each element of the iterator.
547fn default_extend<ExtendT, I, T>(collection: &mut ExtendT, iter: I)
548where
549    ExtendT: Extend<T>,
550    I: IntoIterator<Item = T>,
551{
552    // Specialize on `TrustedLen` and call `extend_one_unchecked` where
553    // applicable.
554    trait SpecExtend<I> {
555        fn extend(&mut self, iter: I);
556    }
557
558    // Extracting these to separate functions avoid monomorphising the closures
559    // for every iterator type.
560    fn extender<ExtendT, T>(collection: &mut ExtendT) -> impl FnMut(T) + use<'_, ExtendT, T>
561    where
562        ExtendT: Extend<T>,
563    {
564        move |item| collection.extend_one(item)
565    }
566
567    unsafe fn unchecked_extender<ExtendT, T>(
568        collection: &mut ExtendT,
569    ) -> impl FnMut(T) + use<'_, ExtendT, T>
570    where
571        ExtendT: Extend<T>,
572    {
573        // SAFETY: we make sure that there is enough space at the callsite of
574        // this function.
575        move |item| unsafe { collection.extend_one_unchecked(item) }
576    }
577
578    impl<ExtendT, I, T> SpecExtend<I> for ExtendT
579    where
580        ExtendT: Extend<T>,
581        I: Iterator<Item = T>,
582    {
583        default fn extend(&mut self, iter: I) {
584            let (lower_bound, _) = iter.size_hint();
585            if lower_bound > 0 {
586                self.extend_reserve(lower_bound);
587            }
588
589            iter.for_each(extender(self))
590        }
591    }
592
593    impl<ExtendT, I, T> SpecExtend<I> for ExtendT
594    where
595        ExtendT: Extend<T>,
596        I: TrustedLen<Item = T>,
597    {
598        fn extend(&mut self, iter: I) {
599            let (lower_bound, upper_bound) = iter.size_hint();
600            if lower_bound > 0 {
601                self.extend_reserve(lower_bound);
602            }
603
604            if upper_bound.is_none() {
605                // We cannot reserve more than `usize::MAX` items, and this is likely to go out of memory anyway.
606                iter.for_each(extender(self))
607            } else {
608                // SAFETY: We reserve enough space for the `size_hint`, and the iterator is
609                // `TrustedLen` so its `size_hint` is exact.
610                iter.for_each(unsafe { unchecked_extender(self) })
611            }
612        }
613    }
614
615    SpecExtend::extend(collection, iter.into_iter());
616}
617
618// Implements `Extend` and `FromIterator` for tuples with length larger than one.
619macro_rules! impl_extend_tuple {
620    ($(($ty:tt, $extend_ty:tt, $index:tt)),+) => {
621        #[doc(hidden)]
622        #[stable(feature = "extend_for_tuple", since = "1.56.0")]
623        impl<$($ty,)+ $($extend_ty,)+> Extend<($($ty,)+)> for ($($extend_ty,)+)
624        where
625            $($extend_ty: Extend<$ty>,)+
626        {
627            fn extend<T: IntoIterator<Item = ($($ty,)+)>>(&mut self, iter: T) {
628                default_extend(self, iter)
629            }
630
631            fn extend_one(&mut self, item: ($($ty,)+)) {
632                $(self.$index.extend_one(item.$index);)+
633            }
634
635            fn extend_reserve(&mut self, additional: usize) {
636                $(self.$index.extend_reserve(additional);)+
637            }
638
639            unsafe fn extend_one_unchecked(&mut self, item: ($($ty,)+)) {
640                // SAFETY: Those are our safety preconditions, and we correctly forward `extend_reserve`.
641                unsafe {
642                    $(self.$index.extend_one_unchecked(item.$index);)+
643                }
644            }
645        }
646
647        #[doc(hidden)]
648        #[stable(feature = "from_iterator_for_tuple", since = "1.79.0")]
649        impl<$($ty,)+ $($extend_ty,)+> FromIterator<($($ty,)+)> for ($($extend_ty,)+)
650        where
651            $($extend_ty: Default + Extend<$ty>,)+
652        {
653            fn from_iter<Iter: IntoIterator<Item = ($($ty,)+)>>(iter: Iter) -> Self {
654                let mut res = Self::default();
655                res.extend(iter);
656                res
657            }
658        }
659    };
660}
661
662impl_extend_tuple!((A, ExA, 0), (B, ExB, 1));
663impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2));
664impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2), (D, ExD, 3));
665impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2), (D, ExD, 3), (E, ExE, 4));
666impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2), (D, ExD, 3), (E, ExE, 4), (F, ExF, 5));
667impl_extend_tuple!(
668    (A, ExA, 0),
669    (B, ExB, 1),
670    (C, ExC, 2),
671    (D, ExD, 3),
672    (E, ExE, 4),
673    (F, ExF, 5),
674    (G, ExG, 6)
675);
676impl_extend_tuple!(
677    (A, ExA, 0),
678    (B, ExB, 1),
679    (C, ExC, 2),
680    (D, ExD, 3),
681    (E, ExE, 4),
682    (F, ExF, 5),
683    (G, ExG, 6),
684    (H, ExH, 7)
685);
686impl_extend_tuple!(
687    (A, ExA, 0),
688    (B, ExB, 1),
689    (C, ExC, 2),
690    (D, ExD, 3),
691    (E, ExE, 4),
692    (F, ExF, 5),
693    (G, ExG, 6),
694    (H, ExH, 7),
695    (I, ExI, 8)
696);
697impl_extend_tuple!(
698    (A, ExA, 0),
699    (B, ExB, 1),
700    (C, ExC, 2),
701    (D, ExD, 3),
702    (E, ExE, 4),
703    (F, ExF, 5),
704    (G, ExG, 6),
705    (H, ExH, 7),
706    (I, ExI, 8),
707    (J, ExJ, 9)
708);
709impl_extend_tuple!(
710    (A, ExA, 0),
711    (B, ExB, 1),
712    (C, ExC, 2),
713    (D, ExD, 3),
714    (E, ExE, 4),
715    (F, ExF, 5),
716    (G, ExG, 6),
717    (H, ExH, 7),
718    (I, ExI, 8),
719    (J, ExJ, 9),
720    (K, ExK, 10)
721);
722impl_extend_tuple!(
723    (A, ExA, 0),
724    (B, ExB, 1),
725    (C, ExC, 2),
726    (D, ExD, 3),
727    (E, ExE, 4),
728    (F, ExF, 5),
729    (G, ExG, 6),
730    (H, ExH, 7),
731    (I, ExI, 8),
732    (J, ExJ, 9),
733    (K, ExK, 10),
734    (L, ExL, 11)
735);
core/iter/traits/collect.rs

core/iter/traits/
collect.rs
