---

yaml
---
r: 61417
b: refs/heads/try
c: 08ef229
h: refs/heads/master
i:
  61415: 33f8c36
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
-refs/heads/try: c99d1de85bcc7fff69b6ad4f3159fef8707d304b
+refs/heads/try: 08ef229a65cd7b8de27a5844eee3dce8c69aa846
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/iter.rs

@@ -43,6 +43,8 @@ much easier to implement.
 #[cfg(not(stage0))] use cmp::Ord;
 #[cfg(not(stage0))] use option::{Option, Some, None};
 #[cfg(not(stage0))] use vec::OwnedVector;
+#[cfg(not(stage0))] use num::{One, Zero};
+#[cfg(not(stage0))] use ops::{Add, Mul};
 
 #[cfg(stage0)]
 pub trait Times {
@@ -212,6 +214,81 @@ pub fn min<T: Ord>(iter: &fn(f: &fn(T) -> bool) -> bool) -> Option<T> {
     result
 }
 
+/**
+ * Reduce an iterator to an accumulated value.
+ *
+ * # Example:
+ *
+ * ~~~~
+ * assert_eq!(fold(0i, |f| int::range(1, 5, f), |a, x| *a += x), 10);
+ * ~~~~
+ */
+#[cfg(not(stage0))]
+#[inline]
+pub fn fold<T, U>(start: T, iter: &fn(f: &fn(U) -> bool) -> bool, f: &fn(&mut T, U)) -> T {
+    let mut result = start;
+    for iter |x| {
+        f(&mut result, x);
+    }
+    result
+}
+
+/**
+ * Reduce an iterator to an accumulated value.
+ *
+ * `fold_ref` is usable in some generic functions where `fold` is too lenient to type-check, but it
+ * forces the iterator to yield borrowed pointers.
+ *
+ * # Example:
+ *
+ * ~~~~
+ * fn product<T: One + Mul<T, T>>(iter: &fn(f: &fn(&T) -> bool) -> bool) -> T {
+ *     fold_ref(One::one::<T>(), iter, |a, x| *a = a.mul(x))
+ * }
+ * ~~~~
+ */
+#[cfg(not(stage0))]
+#[inline]
+pub fn fold_ref<T, U>(start: T, iter: &fn(f: &fn(&U) -> bool) -> bool, f: &fn(&mut T, &U)) -> T {
+    let mut result = start;
+    for iter |x| {
+        f(&mut result, x);
+    }
+    result
+}
+
+/**
+ * Return the sum of the items yielding by an iterator.
+ *
+ * # Example:
+ *
+ * ~~~~
+ * let xs: ~[int] = ~[1, 2, 3, 4];
+ * assert_eq!(do sum |f| { xs.each(f) }, 10);
+ * ~~~~
+ */
+#[cfg(not(stage0))]
+#[inline(always)]
+pub fn sum<T: Zero + Add<T, T>>(iter: &fn(f: &fn(&T) -> bool) -> bool) -> T {
+    fold_ref(Zero::zero::<T>(), iter, |a, x| *a = a.add(x))
+}
+
+/**
+ * Return the product of the items yielded by an iterator.
+ *
+ * # Example:
+ *
+ * ~~~~
+ * let xs: ~[int] = ~[1, 2, 3, 4];
+ * assert_eq!(do product |f| { xs.each(f) }, 24);
+ * ~~~~
+ */
+#[cfg(not(stage0))]
+#[inline(always)]
+pub fn product<T: One + Mul<T, T>>(iter: &fn(f: &fn(&T) -> bool) -> bool) -> T {
+    fold_ref(One::one::<T>(), iter, |a, x| *a = a.mul(x))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -254,4 +331,33 @@ mod tests {
         let xs = ~[8, 2, 3, 1, -5, 9, 11, 15];
         assert_eq!(min(|f| xs.each(f)).unwrap(), &-5);
     }
+
+    #[test]
+    fn test_fold() {
+        assert_eq!(fold(0i, |f| int::range(1, 5, f), |a, x| *a += x), 10);
+    }
+
+    #[test]
+    fn test_sum() {
+        let xs: ~[int] = ~[1, 2, 3, 4];
+        assert_eq!(do sum |f| { xs.each(f) }, 10);
+    }
+
+    #[test]
+    fn test_empty_sum() {
+        let xs: ~[int] = ~[];
+        assert_eq!(do sum |f| { xs.each(f) }, 0);
+    }
+
+    #[test]
+    fn test_product() {
+        let xs: ~[int] = ~[1, 2, 3, 4];
+        assert_eq!(do product |f| { xs.each(f) }, 24);
+    }
+
+    #[test]
+    fn test_empty_product() {
+        let xs: ~[int] = ~[];
+        assert_eq!(do product |f| { xs.each(f) }, 1);
+    }
 }

branches/try/src/libcore/vec.rs

@@ -1445,46 +1445,6 @@ pub fn reverse<T>(v: &mut [T]) {
     }
 }
 
-/**
- * Reverse part of a vector in place.
- *
- * Reverse the elements in the vector between `start` and `end - 1`.
- *
- * If either start or end do not represent valid positions in the vector, the
- * vector is returned unchanged.
- *
- * # Arguments
- *
- * * `v` - The mutable vector to be modified
- *
- * * `start` - Index of the first element of the slice
- *
- * * `end` - Index one past the final element to be reversed.
- *
- * # Example
- *
- * Assume a mutable vector `v` contains `[1,2,3,4,5]`. After the call:
- *
- * ~~~
- *
- * reverse_part(v, 1, 4);
- *
- * ~~~
- *
- * `v` now contains `[1,4,3,2,5]`.
- */
-pub fn reverse_part<T>(v: &mut [T], start: uint, end : uint) {
-    let sz = v.len();
-    if start >= sz || end > sz { return; }
-    let mut i = start;
-    let mut j = end - 1;
-    while i < j {
-        vec::swap(v, i, j);
-        i += 1;
-        j -= 1;
-    }
-}
-
 /// Returns a vector with the order of elements reversed
 pub fn reversed<T:Copy>(v: &const [T]) -> ~[T] {
     let mut rs: ~[T] = ~[];
@@ -1779,69 +1739,29 @@ pub fn each2_mut<U, T>(v1: &mut [U], v2: &mut [T], f: &fn(u: &mut U, t: &mut T)
  *
  * The total number of permutations produced is `len(v)!`.  If `v` contains
  * repeated elements, then some permutations are repeated.
- *
- * See [Algorithms to generate
- * permutations](http://en.wikipedia.org/wiki/Permutation).
- *
- *  # Arguments
- *
- *  * `values` - A vector of values from which the permutations are
- *  chosen
- *
- *  * `fun` - The function to iterate over the combinations
  */
-pub fn each_permutation<T:Copy>(values: &[T], fun: &fn(perm : &[T]) -> bool) {
-    let length = values.len();
-    let mut permutation = vec::from_fn(length, |i| values[i]);
-    if length <= 1 {
-        fun(permutation);
-        return;
-    }
-    let mut indices = vec::from_fn(length, |i| i);
-    loop {
-        if !fun(permutation) { return; }
-        // find largest k such that indices[k] < indices[k+1]
-        // if no such k exists, all permutations have been generated
-        let mut k = length - 2;
-        while k > 0 && indices[k] >= indices[k+1] {
-            k -= 1;
-        }
-        if k == 0 && indices[0] > indices[1] { return; }
-        // find largest l such that indices[k] < indices[l]
-        // k+1 is guaranteed to be such
-        let mut l = length - 1;
-        while indices[k] >= indices[l] {
-            l -= 1;
-        }
-        // swap indices[k] and indices[l]; sort indices[k+1..]
-        // (they're just reversed)
-        vec::swap(indices, k, l);
-        reverse_part(indices, k+1, length);
-        // fixup permutation based on indices
-        for uint::range(k, length) |i| {
-            permutation[i] = values[indices[i]];
+#[cfg(not(stage0))]
+pub fn each_permutation<T:Copy>(v: &[T], put: &fn(ts: &[T]) -> bool) -> bool {
+    let ln = len(v);
+    if ln <= 1 {
+        put(v);
+    } else {
+        // This does not seem like the most efficient implementation.  You
+        // could make far fewer copies if you put your mind to it.
+        let mut i = 0u;
+        while i < ln {
+            let elt = v[i];
+            let mut rest = slice(v, 0u, i).to_vec();
+            rest.push_all(const_slice(v, i+1u, ln));
+            for each_permutation(rest) |permutation| {
+                if !put(append(~[elt], permutation)) {
+                    return false;
+                }
+            }
+            i += 1u;
         }
     }
-}
-
-/**
- * Iterate over all permutations of vector `values`.
- *
- * This is an alternative to each_permutation that uses references to
- * avoid copying the elements of the values vector.
- *
- * To avoid copying, the iterator will be passed a reference to a vector
- * containing references to the elements in the original `values` vector.
- *
- * # Arguments
- *
- * * `values` - A vector of values from which the permutations are chosen
- *
- * * `fun` - The function to iterate over the permutations
- */
-#[cfg(not(stage0))]
-pub fn each_permutation_ref<T>(values : &[T], fun : &fn(perm : &[&T]) -> bool) {
-    each_permutation(vec::from_fn(values.len(), |i| &values[i]), fun);
+    return true;
 }
 
 /**
@@ -4810,93 +4730,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_reverse_part() {
-        let mut values = [1,2,3,4,5];
-        reverse_part(values,1,4);
-        assert_eq!(values, [1,4,3,2,5]);
-    }
-
-    #[test]
-    fn test_permutations0() {
-        let values = [];
-        let mut v : ~[~[int]] = ~[];
-        for each_permutation(values) |p| {
-            v.push(p.to_owned());
-        }
-        assert_eq!(v, ~[~[]]);
-    }
-
-    #[test]
-    fn test_permutations0_ref() {
-        let values = [];
-        let mut v : ~[~[int]] = ~[];
-        for each_permutation_ref(values) |p| {
-            v.push(p.to_owned());
-        }
-        assert_eq!(v, ~[~[]]);
-    }
-
-    #[test]
-    fn test_permutations1() {
-        let values = [1];
-        let mut v : ~[~[int]] = ~[];
-        for each_permutation(values) |p| {
-            v.push(p.to_owned());
-        }
-        assert_eq!(v, ~[~[1]]);
-    }
-
-    #[test]
-    fn test_permutations1_ref() {
-        let values = [1];
-        let mut v : ~[~[int]] = ~[];
-        for each_permutation_ref(values) |p| {
-            v.push(p.to_owned());
-        }
-        assert_eq!(v, ~[~[1]]);
-    }
-
-    #[test]
-    fn test_permutations2() {
-        let values = [1,2];
-        let mut v : ~[~[int]] = ~[];
-        for each_permutation(values) |p| {
-            v.push(p.to_owned());
-        }
-        assert_eq!(v, ~[~[1,2],~[2,1]]);
-    }
-
-    #[test]
-    fn test_permutations2_ref() {
-        let values = [1,2];
-        let mut v : ~[~[int]] = ~[];
-        for each_permutation_ref(values) |p| {
-            v.push(p.to_owned());
-        }
-        assert_eq!(v, ~[~[1,2],~[2,1]]);
-    }
-
-    #[test]
-    fn test_permutations3() {
-        let values = [1,2,3];
-        let mut v : ~[~[int]] = ~[];
-        for each_permutation(values) |p| {
-            v.push(p.to_owned());
-        }
-        assert_eq!(v, ~[~[1,2,3],~[1,3,2],~[2,1,3],~[2,3,1],~[3,1,2],~[3,2,1]]);
-    }
-
-    #[test]
-    fn test_permutations3_ref() {
-        let values = [1,2,3];
-        let mut v : ~[~[int]] = ~[];
-        for each_permutation_ref(values) |p| {
-            v.push(p.to_owned());
-        }
-        assert_eq!(v, ~[~[1,2,3],~[1,3,2],~[2,1,3],~[2,3,1],~[3,1,2],~[3,2,1]]);
-    }
-
     #[test]
     fn test_each_val() {
         use old_iter::CopyableNonstrictIter;