@@ -118,7 +118,7 @@ pub trait Iterator<T> {
118118 /// times until [`None`] is encountered.
119119 ///
120120 /// `advance_by(n)` will return `Ok(())` if the iterator successfully advances by
121- /// `n` elements, or a `Err(NonZero<usize>)` with value `k` if [`None`] is encountered,
121+ /// `n` elements, or an `Err(NonZero<usize>)` with value `k` if [`None`] is encountered,
122122 /// where `k` is remaining number of steps that could not be advanced because the iterator ran
123123 /// out.
124124 /// If `self` is empty and `n` is non-zero, then this returns `Err(n)`.
@@ -202,11 +202,11 @@ pub trait Iterator<T> {
202202 }
203203 }
204204
205- /// Takes a closure and creates an iterator which calls that closure on each
205+ /// Takes a closure and creates an iterator that calls that closure on each
206206 /// element.
207207 ///
208208 /// `map()` transforms one iterator into another, by means of its argument:
209- /// something that implements [`FnOnce`]. It produces a new iterator which
209+ /// something that implements [`FnOnce`]. It produces a new iterator that
210210 /// calls this closure on each element of the original iterator.
211211 ///
212212 /// If you are good at thinking in types, you can think of `map()` like this:
@@ -253,7 +253,7 @@ pub trait Iterator<T> {
253253 mapped_iterator (self , f )
254254 }
255255
256- /// Creates an iterator which gives the current iteration count as well as
256+ /// Creates an iterator that gives the current iteration count as well as
257257 /// the next value.
258258 ///
259259 /// The iterator returned yields pairs `(i, val)`, where `i` is the
@@ -508,7 +508,7 @@ pub trait Iterator<T> {
508508 }
509509 }
510510
511- /// Creates an iterator which uses a closure to determine if an element
511+ /// Creates an iterator that uses a closure to determine if an element
512512 /// should be yielded. The closure takes each element as a snapshot.
513513 ///
514514 /// Given an element the closure must return `true` or `false`. The returned
@@ -554,7 +554,7 @@ pub trait Iterator<T> {
554554 /// If either iterator returns [`None`], [`next`] from the zipped iterator
555555 /// will return [`None`].
556556 /// If the zipped iterator has no more elements to return then each further attempt to advance
557- /// it will first try to advance the first iterator at most one time and if it still yielded an
557+ /// it will first try to advance the first iterator at most one time and if it still yields an
558558 /// item try to advance the second iterator at most one time.
559559 ///
560560 /// # Examples
@@ -654,7 +654,7 @@ pub trait Iterator<T> {
654654 FromIterator :: <B , Self :: Item >:: from_iter :: <T , IntoIter , ItemEqual >(self )
655655 }
656656
657- /// Creates an iterator which can use the [`peek`] method to look at the next element of the
657+ /// Creates an iterator that can use the [`peek`] method to look at the next element of the
658658 /// iterator. See its documentation for more information.
659659 ///
660660 /// Note that the underlying iterator is still advanced when [`peek`] is called for the first
@@ -712,7 +712,7 @@ pub trait Iterator<T> {
712712 /// assert_eq!(iter.next(), None);
713713 /// ```
714714 ///
715- /// If less than `n` elements are available,
715+ /// If fewer than `n` elements are available,
716716 /// `take` will limit itself to the size of the underlying iterator:
717717 ///
718718 /// ```
0 commit comments