/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn zip<B, U>(self, other: U) -> Zip<Self, U> where
- U: Iterator<Item=B>,
- {
+ fn zip<U: Iterator>(self, other: U) -> Zip<Self, U> {
Zip{a: self, b: other}
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn map<B, F>(self, f: F) -> Map<Self::Item, B, Self, F> where
+ fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
{
Map{iter: self, f: f}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn filter<P>(self, predicate: P) -> Filter<Self::Item, Self, P> where
+ fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
{
Filter{iter: self, predicate: predicate}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn filter_map<B, F>(self, f: F) -> FilterMap<Self::Item, B, Self, F> where
+ fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
{
FilterMap { iter: self, f: f }
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn peekable(self) -> Peekable<Self::Item, Self> {
+ fn peekable(self) -> Peekable<Self> {
Peekable{iter: self, peeked: None}
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn skip_while<P>(self, predicate: P) -> SkipWhile<Self::Item, Self, P> where
+ fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
{
SkipWhile{iter: self, flag: false, predicate: predicate}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn take_while<P>(self, predicate: P) -> TakeWhile<Self::Item, Self, P> where
+ fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
{
TakeWhile{iter: self, flag: false, predicate: predicate}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn scan<St, B, F>(
- self,
- initial_state: St,
- f: F,
- ) -> Scan<Self::Item, B, Self, St, F> where
- F: FnMut(&mut St, Self::Item) -> Option<B>,
+ fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
+ where F: FnMut(&mut St, Self::Item) -> Option<B>,
{
Scan{iter: self, f: f, state: initial_state}
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn flat_map<B, U, F>(self, f: F) -> FlatMap<Self::Item, B, Self, U, F> where
- U: Iterator<Item=B>,
- F: FnMut(Self::Item) -> U,
+ fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
+ where U: Iterator, F: FnMut(Self::Item) -> U,
{
FlatMap{iter: self, f: f, frontiter: None, backiter: None }
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn inspect<F>(self, f: F) -> Inspect<Self::Item, Self, F> where
+ fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
{
Inspect{iter: self, f: f}
#[stable(feature = "rust1", since = "1.0.0")]
impl<I> ExactSizeIterator for Enumerate<I> where I: ExactSizeIterator {}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, I, F> ExactSizeIterator for Inspect<A, I, F> where
- I: ExactSizeIterator<Item=A>,
- F: FnMut(&A),
+impl<I: ExactSizeIterator, F> ExactSizeIterator for Inspect<I, F> where
+ F: FnMut(&I::Item),
{}
#[stable(feature = "rust1", since = "1.0.0")]
impl<I> ExactSizeIterator for Rev<I> where I: ExactSizeIterator + DoubleEndedIterator {}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, F> ExactSizeIterator for Map<A, B, I, F> where
- I: ExactSizeIterator<Item=A>,
- F: FnMut(A) -> B,
+impl<B, I: ExactSizeIterator, F> ExactSizeIterator for Map<I, F> where
+ F: FnMut(I::Item) -> B,
{}
#[stable(feature = "rust1", since = "1.0.0")]
impl<A, B> ExactSizeIterator for Zip<A, B> where A: ExactSizeIterator, B: ExactSizeIterator {}
/// An iterator that maps the values of `iter` with `f`
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Map<A, B, I: Iterator<Item=A>, F: FnMut(A) -> B> {
+#[derive(Clone)]
+pub struct Map<I, F> {
iter: I,
f: F,
}
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, F> Clone for Map<A, B, I, F> where
- I: Clone + Iterator<Item=A>,
- F: Clone + FnMut(A) -> B,
-{
- fn clone(&self) -> Map<A, B, I, F> {
- Map {
- iter: self.iter.clone(),
- f: self.f.clone(),
- }
- }
-}
-
-impl<A, B, I, F> Map<A, B, I, F> where I: Iterator<Item=A>, F: FnMut(A) -> B {
+impl<I: Iterator, F, B> Map<I, F> where F: FnMut(I::Item) -> B {
#[inline]
- fn do_map(&mut self, elt: Option<A>) -> Option<B> {
+ fn do_map(&mut self, elt: Option<I::Item>) -> Option<B> {
match elt {
Some(a) => Some((self.f)(a)),
_ => None
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, F> Iterator for Map<A, B, I, F> where I: Iterator<Item=A>, F: FnMut(A) -> B {
+impl<B, I: Iterator, F> Iterator for Map<I, F> where F: FnMut(I::Item) -> B {
type Item = B;
#[inline]
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, F> DoubleEndedIterator for Map<A, B, I, F> where
- I: DoubleEndedIterator<Item=A>,
- F: FnMut(A) -> B,
+impl<B, I: DoubleEndedIterator, F> DoubleEndedIterator for Map<I, F> where
+ F: FnMut(I::Item) -> B,
{
#[inline]
fn next_back(&mut self) -> Option<B> {
}
#[unstable(feature = "core", reason = "trait is experimental")]
-impl<A, B, I, F> RandomAccessIterator for Map<A, B, I, F> where
- I: RandomAccessIterator<Item=A>,
- F: FnMut(A) -> B,
+impl<B, I: RandomAccessIterator, F> RandomAccessIterator for Map<I, F> where
+ F: FnMut(I::Item) -> B,
{
#[inline]
fn indexable(&self) -> usize {
/// An iterator that filters the elements of `iter` with `predicate`
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Filter<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
+#[derive(Clone)]
+pub struct Filter<I, P> {
iter: I,
predicate: P,
}
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, I, P> Clone for Filter<A, I, P> where
- I: Clone + Iterator<Item=A>,
- P: Clone + FnMut(&A) -> bool,
-{
- fn clone(&self) -> Filter<A, I, P> {
- Filter {
- iter: self.iter.clone(),
- predicate: self.predicate.clone(),
- }
- }
-}
-
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, I, P> Iterator for Filter<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
- type Item = A;
+impl<I: Iterator, P> Iterator for Filter<I, P> where P: FnMut(&I::Item) -> bool {
+ type Item = I::Item;
#[inline]
- fn next(&mut self) -> Option<A> {
+ fn next(&mut self) -> Option<I::Item> {
for x in self.iter.by_ref() {
if (self.predicate)(&x) {
return Some(x);
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, I, P> DoubleEndedIterator for Filter<A, I, P> where
- I: DoubleEndedIterator<Item=A>,
- P: FnMut(&A) -> bool,
+impl<I: DoubleEndedIterator, P> DoubleEndedIterator for Filter<I, P>
+ where P: FnMut(&I::Item) -> bool,
{
#[inline]
- fn next_back(&mut self) -> Option<A> {
+ fn next_back(&mut self) -> Option<I::Item> {
for x in self.iter.by_ref().rev() {
if (self.predicate)(&x) {
return Some(x);
/// An iterator that uses `f` to both filter and map elements from `iter`
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[stable(feature = "rust1", since = "1.0.0")]
-pub struct FilterMap<A, B, I, F> where I: Iterator<Item=A>, F: FnMut(A) -> Option<B> {
+#[derive(Clone)]
+pub struct FilterMap<I, F> {
iter: I,
f: F,
}
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, F> Clone for FilterMap<A, B, I, F> where
- I: Clone + Iterator<Item=A>,
- F: Clone + FnMut(A) -> Option<B>,
-{
- fn clone(&self) -> FilterMap<A, B, I, F> {
- FilterMap {
- iter: self.iter.clone(),
- f: self.f.clone(),
- }
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, F> Iterator for FilterMap<A, B, I, F> where
- I: Iterator<Item=A>,
- F: FnMut(A) -> Option<B>,
+impl<B, I: Iterator, F> Iterator for FilterMap<I, F>
+ where F: FnMut(I::Item) -> Option<B>,
{
type Item = B;
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, F> DoubleEndedIterator for FilterMap<A, B, I, F> where
- I: DoubleEndedIterator<Item=A>,
- F: FnMut(A) -> Option<B>,
+impl<B, I: DoubleEndedIterator, F> DoubleEndedIterator for FilterMap<I, F>
+ where F: FnMut(I::Item) -> Option<B>,
{
#[inline]
fn next_back(&mut self) -> Option<B> {
}
/// An iterator with a `peek()` that returns an optional reference to the next element.
-#[derive(Clone)]
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Peekable<T, I> where I: Iterator<Item=T> {
+pub struct Peekable<I: Iterator> {
iter: I,
- peeked: Option<T>,
+ peeked: Option<I::Item>,
+}
+
+impl<I: Iterator + Clone> Clone for Peekable<I> where I::Item: Clone {
+ fn clone(&self) -> Peekable<I> {
+ Peekable {
+ iter: self.iter.clone(),
+ peeked: self.peeked.clone(),
+ }
+ }
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, I> Iterator for Peekable<T, I> where I: Iterator<Item=T> {
- type Item = T;
+impl<I: Iterator> Iterator for Peekable<I> {
+ type Item = I::Item;
#[inline]
- fn next(&mut self) -> Option<T> {
+ fn next(&mut self) -> Option<I::Item> {
if self.peeked.is_some() { self.peeked.take() }
else { self.iter.next() }
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, I> ExactSizeIterator for Peekable<T, I> where I: ExactSizeIterator<Item = T> {}
+impl<I: ExactSizeIterator> ExactSizeIterator for Peekable<I> {}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, I> Peekable<T, I> where I: Iterator<Item=T> {
- /// Return a reference to the next element of the iterator with out advancing it,
- /// or None if the iterator is exhausted.
+impl<I: Iterator> Peekable<I> {
+ /// Return a reference to the next element of the iterator with out
+ /// advancing it, or None if the iterator is exhausted.
#[inline]
- pub fn peek(&mut self) -> Option<&T> {
+ pub fn peek(&mut self) -> Option<&I::Item> {
if self.peeked.is_none() {
self.peeked = self.iter.next();
}
/// An iterator that rejects elements while `predicate` is true
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[stable(feature = "rust1", since = "1.0.0")]
-pub struct SkipWhile<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
+#[derive(Clone)]
+pub struct SkipWhile<I, P> {
iter: I,
flag: bool,
predicate: P,
}
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, I, P> Clone for SkipWhile<A, I, P> where
- I: Clone + Iterator<Item=A>,
- P: Clone + FnMut(&A) -> bool,
+impl<I: Iterator, P> Iterator for SkipWhile<I, P>
+ where P: FnMut(&I::Item) -> bool
{
- fn clone(&self) -> SkipWhile<A, I, P> {
- SkipWhile {
- iter: self.iter.clone(),
- flag: self.flag,
- predicate: self.predicate.clone(),
- }
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, I, P> Iterator for SkipWhile<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
- type Item = A;
+ type Item = I::Item;
#[inline]
- fn next(&mut self) -> Option<A> {
+ fn next(&mut self) -> Option<I::Item> {
for x in self.iter.by_ref() {
if self.flag || !(self.predicate)(&x) {
self.flag = true;
/// An iterator that only accepts elements while `predicate` is true
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[stable(feature = "rust1", since = "1.0.0")]
-pub struct TakeWhile<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
+#[derive(Clone)]
+pub struct TakeWhile<I, P> {
iter: I,
flag: bool,
predicate: P,
}
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, I, P> Clone for TakeWhile<A, I, P> where
- I: Clone + Iterator<Item=A>,
- P: Clone + FnMut(&A) -> bool,
+impl<I: Iterator, P> Iterator for TakeWhile<I, P>
+ where P: FnMut(&I::Item) -> bool
{
- fn clone(&self) -> TakeWhile<A, I, P> {
- TakeWhile {
- iter: self.iter.clone(),
- flag: self.flag,
- predicate: self.predicate.clone(),
- }
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, I, P> Iterator for TakeWhile<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
- type Item = A;
+ type Item = I::Item;
#[inline]
- fn next(&mut self) -> Option<A> {
+ fn next(&mut self) -> Option<I::Item> {
if self.flag {
None
} else {
/// An iterator to maintain state while iterating another iterator
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Scan<A, B, I, St, F> where I: Iterator, F: FnMut(&mut St, A) -> Option<B> {
+#[derive(Clone)]
+pub struct Scan<I, St, F> {
iter: I,
f: F,
pub state: St,
}
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, St, F> Clone for Scan<A, B, I, St, F> where
- I: Clone + Iterator<Item=A>,
- St: Clone,
- F: Clone + FnMut(&mut St, A) -> Option<B>,
-{
- fn clone(&self) -> Scan<A, B, I, St, F> {
- Scan {
- iter: self.iter.clone(),
- f: self.f.clone(),
- state: self.state.clone(),
- }
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, St, F> Iterator for Scan<A, B, I, St, F> where
- I: Iterator<Item=A>,
- F: FnMut(&mut St, A) -> Option<B>,
+impl<B, I: Iterator, St, F> Iterator for Scan<I, St, F> where
+ F: FnMut(&mut St, I::Item) -> Option<B>,
{
type Item = B;
///
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[stable(feature = "rust1", since = "1.0.0")]
-pub struct FlatMap<A, B, I, U, F> where
- I: Iterator<Item=A>,
- U: Iterator<Item=B>,
- F: FnMut(A) -> U,
-{
+#[derive(Clone)]
+pub struct FlatMap<I, U, F> {
iter: I,
f: F,
frontiter: Option<U>,
backiter: Option<U>,
}
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, U, F> Clone for FlatMap<A, B, I, U, F> where
- I: Clone + Iterator<Item=A>,
- U: Clone + Iterator<Item=B>,
- F: Clone + FnMut(A) -> U,
-{
- fn clone(&self) -> FlatMap<A, B, I, U, F> {
- FlatMap {
- iter: self.iter.clone(),
- f: self.f.clone(),
- frontiter: self.frontiter.clone(),
- backiter: self.backiter.clone(),
- }
- }
-}
-
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, U, F> Iterator for FlatMap<A, B, I, U, F> where
- I: Iterator<Item=A>,
- U: Iterator<Item=B>,
- F: FnMut(A) -> U,
+impl<I: Iterator, U: Iterator, F> Iterator for FlatMap<I, U, F>
+ where F: FnMut(I::Item) -> U,
{
- type Item = B;
+ type Item = U::Item;
#[inline]
- fn next(&mut self) -> Option<B> {
+ fn next(&mut self) -> Option<U::Item> {
loop {
for inner in self.frontiter.iter_mut() {
for x in inner.by_ref() {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B, I, U, F> DoubleEndedIterator for FlatMap<A, B, I, U, F> where
- I: DoubleEndedIterator<Item=A>,
- U: DoubleEndedIterator<Item=B>,
- F: FnMut(A) -> U,
+impl<I: DoubleEndedIterator, U: DoubleEndedIterator, F> DoubleEndedIterator
+ for FlatMap<I, U, F>
+ where F: FnMut(I::Item) -> U
{
#[inline]
- fn next_back(&mut self) -> Option<B> {
+ fn next_back(&mut self) -> Option<U::Item> {
loop {
for inner in self.backiter.iter_mut() {
match inner.next_back() {
/// element before yielding it.
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Inspect<A, I, F> where I: Iterator<Item=A>, F: FnMut(&A) {
+#[derive(Clone)]
+pub struct Inspect<I, F> {
iter: I,
f: F,
}
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, I, F> Clone for Inspect<A, I, F> where
- I: Clone + Iterator<Item=A>,
- F: Clone + FnMut(&A),
-{
- fn clone(&self) -> Inspect<A, I, F> {
- Inspect {
- iter: self.iter.clone(),
- f: self.f.clone(),
- }
- }
-}
-
-impl<A, I, F> Inspect<A, I, F> where I: Iterator<Item=A>, F: FnMut(&A) {
+impl<I: Iterator, F> Inspect<I, F> where F: FnMut(&I::Item) {
#[inline]
- fn do_inspect(&mut self, elt: Option<A>) -> Option<A> {
+ fn do_inspect(&mut self, elt: Option<I::Item>) -> Option<I::Item> {
match elt {
Some(ref a) => (self.f)(a),
None => ()
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, I, F> Iterator for Inspect<A, I, F> where I: Iterator<Item=A>, F: FnMut(&A) {
- type Item = A;
+impl<I: Iterator, F> Iterator for Inspect<I, F> where F: FnMut(&I::Item) {
+ type Item = I::Item;
#[inline]
- fn next(&mut self) -> Option<A> {
+ fn next(&mut self) -> Option<I::Item> {
let next = self.iter.next();
self.do_inspect(next)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, I, F> DoubleEndedIterator for Inspect<A, I, F> where
- I: DoubleEndedIterator<Item=A>,
- F: FnMut(&A),
+impl<I: DoubleEndedIterator, F> DoubleEndedIterator for Inspect<I, F>
+ where F: FnMut(&I::Item),
{
#[inline]
- fn next_back(&mut self) -> Option<A> {
+ fn next_back(&mut self) -> Option<I::Item> {
let next = self.iter.next_back();
self.do_inspect(next)
}
}
#[unstable(feature = "core", reason = "trait is experimental")]
-impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where
- I: RandomAccessIterator<Item=A>,
- F: FnMut(&A),
+impl<I: RandomAccessIterator, F> RandomAccessIterator for Inspect<I, F>
+ where F: FnMut(&I::Item),
{
#[inline]
fn indexable(&self) -> usize {
}
#[inline]
- fn idx(&mut self, index: usize) -> Option<A> {
+ fn idx(&mut self, index: usize) -> Option<I::Item> {
let element = self.iter.idx(index);
self.do_inspect(element)
}
/// use std::iter::Unfold;
/// use std::num::Int; // For `.checked_add()`
///
-/// // This iterator will yield up to the last Fibonacci number before the max value of `u32`.
-/// // You can simply change `u32` to `u64` in this line if you want higher values than that.
-/// let mut fibonacci = Unfold::new((Some(0u32), Some(1u32)), |&mut (ref mut x2, ref mut x1)| {
+/// // This iterator will yield up to the last Fibonacci number before the max
+/// // value of `u32`. You can simply change `u32` to `u64` in this line if
+/// // you want higher values than that.
+/// let mut fibonacci = Unfold::new((Some(0u32), Some(1u32)),
+/// |&mut (ref mut x2, ref mut x1)| {
/// // Attempt to get the next Fibonacci number
/// // `x1` will be `None` if previously overflowed.
/// let next = match (*x2, *x1) {
/// }
/// ```
#[unstable(feature = "core")]
-pub struct Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
+#[derive(Clone)]
+pub struct Unfold<St, F> {
f: F,
/// Internal state that will be passed to the closure on the next iteration
pub state: St,
}
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, St, F> Clone for Unfold<A, St, F> where
- F: Clone + FnMut(&mut St) -> Option<A>,
- St: Clone,
-{
- fn clone(&self) -> Unfold<A, St, F> {
- Unfold {
- f: self.f.clone(),
- state: self.state.clone(),
- }
- }
-}
-
#[unstable(feature = "core")]
-impl<A, St, F> Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
+impl<A, St, F> Unfold<St, F> where F: FnMut(&mut St) -> Option<A> {
/// Creates a new iterator with the specified closure as the "iterator
/// function" and an initial state to eventually pass to the closure
#[inline]
- pub fn new(initial_state: St, f: F) -> Unfold<A, St, F> {
+ pub fn new(initial_state: St, f: F) -> Unfold<St, F> {
Unfold {
f: f,
state: initial_state
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A, St, F> Iterator for Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
+impl<A, St, F> Iterator for Unfold<St, F> where F: FnMut(&mut St) -> Option<A> {
type Item = A;
#[inline]
/// An iterator that repeatedly applies a given function, starting
/// from a given seed value.
#[unstable(feature = "core")]
-pub type Iterate<T, F> = Unfold<T, IterateState<T, F>, fn(&mut IterateState<T, F>) -> Option<T>>;
+pub type Iterate<T, F> = Unfold<IterateState<T, F>, fn(&mut IterateState<T, F>) -> Option<T>>;
/// Create a new iterator that produces an infinite sequence of
/// repeated applications of the given function `f`.