---

yaml
---
r: 123834
b: refs/heads/auto
c: ed54162
h: refs/heads/master
v: v3

Author: Jakub Wieczorek

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 55cf6d723c40bf720d7d9f9ed3a5833caa8faf1a
+refs/heads/auto: ed54162e86cd00b7a4ced8957aac7f56897f6fb5
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/libcore/iter.rs

@@ -64,14 +64,14 @@ the rest of the rust manuals.
 
 */
 
+use clone::Clone;
 use cmp;
+use cmp::{PartialEq, PartialOrd, Ord};
+use mem;
 use num::{Zero, One, CheckedAdd, CheckedSub, Saturating, ToPrimitive, Int};
-use option::{Option, Some, None};
 use ops::{Add, Mul, Sub};
-use cmp::{PartialEq, PartialOrd, Ord};
-use clone::Clone;
+use option::{Option, Some, None};
 use uint;
-use mem;
 
 /// Conversion from an `Iterator`
 pub trait FromIterator<A> {
@@ -2192,6 +2192,27 @@ impl<A: Clone> RandomAccessIterator<A> for Repeat<A> {
     fn idx(&mut self, _: uint) -> Option<A> { Some(self.element.clone()) }
 }
 
+type IterateState<'a, T> = (|T|: 'a -> T, Option<T>, bool);
+
+/// An iterator that repeatedly applies a given function, starting
+/// from a given seed value.
+pub type Iterate<'a, T> = Unfold<'a, T, IterateState<'a, T>>;
+
+/// Creates a new iterator that produces an infinite sequence of
+/// repeated applications of the given function `f`.
+#[allow(visible_private_types)]
+pub fn iterate<'a, T: Clone>(f: |T|: 'a -> T, seed: T) -> Iterate<'a, T> {
+    Unfold::new((f, Some(seed), true), |st| {
+        let &(ref mut f, ref mut val, ref mut first) = st;
+        if *first {
+            *first = false;
+        } else {
+            val.mutate(|x| (*f)(x));
+        }
+        val.clone()
+    })
+}
+
 /// Functions for lexicographical ordering of sequences.
 ///
 /// Lexicographical ordering through `<`, `<=`, `>=`, `>` requires

branches/auto/src/libcoretest/iter.rs

@@ -833,3 +833,12 @@ fn test_min_max_result() {
     let r = MinMax(1i,2);
     assert_eq!(r.into_option(), Some((1,2)));
 }
+
+#[test]
+fn test_iterate() {
+    let mut it = iterate(|x| x * 2, 1u);
+    assert_eq!(it.next(), Some(1u));
+    assert_eq!(it.next(), Some(2u));
+    assert_eq!(it.next(), Some(4u));
+    assert_eq!(it.next(), Some(8u));
+}

branches/auto/src/libstd/lib.rs

@@ -78,7 +78,7 @@
 //! passing. [`sync`](sync/index.html) contains further, primitive, shared
 //! memory types, including [`atomics`](sync/atomics/index.html).
 //!
-//! Common types of I/O, including files, TCP, UDP, pipes, Unix domain sockets,
+//! Common types of I/O, including files, TCP, UPD, pipes, Unix domain sockets,
 //! timers, and process spawning, are defined in the [`io`](io/index.html) module.
 //!
 //! Rust's I/O and concurrency depends on a small runtime interface