---

yaml
---
r: 14249
b: refs/heads/try
c: e5cc919
h: refs/heads/master
i:
  14247: bf2d555
v: v3

Author: uasi

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: fde719f635955b1c3d76639062410262fd0df351
+refs/heads/try: e5cc9193f8b91f8d21621b452e45d0e37c200757
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/libcore/iter.rs

@@ -65,43 +65,18 @@ fn flat_map<A,B,IA:iterable<A>,IB:iterable<B>>(
     }
 }
 
-fn foldl<A,B,IA:iterable<A>>(self: IA, +b0: B, blk: fn(-B, A) -> B) -> B {
-    let b <- b0;
+fn foldl<A,B:copy,IA:iterable<A>>(self: IA, b0: B, blk: fn(B, A) -> B) -> B {
+    let b = b0;
     self.iter {|a|
         b = blk(b, a);
     }
     ret b;
 }
 
-fn foldr<A:copy,B,IA:iterable<A>>(
-    self: IA, +b0: B, blk: fn(A, -B) -> B) -> B {
-
-    let b <- b0;
-    reverse(self) {|a|
-        b = blk(a, b);
-    }
-    ret b;
-}
-
 fn to_list<A:copy,IA:iterable<A>>(self: IA) -> [A] {
     foldl::<A,[A],IA>(self, [], {|r, a| r + [a]})
 }
 
-// FIXME: This could be made more efficient with an riterable interface
-fn reverse<A:copy,IA:iterable<A>>(self: IA, blk: fn(A)) {
-    vec::riter(to_list(self), blk)
-}
-
-fn count<A,IA:iterable<A>>(self: IA, x: A) -> uint {
-    foldl(self, 0u) {|count, value|
-        if value == x {
-            count + 1u
-        } else {
-            count
-        }
-    }
-}
-
 fn repeat(times: uint, blk: fn()) {
     let i = 0u;
     while i < times {
@@ -110,35 +85,6 @@ fn repeat(times: uint, blk: fn()) {
     }
 }
 
-fn min<A:copy,IA:iterable<A>>(self: IA) -> A {
-    alt foldl::<A,option<A>,IA>(self, none) {|a, b|
-        alt a {
-          some(a_) if a_ < b {
-            // FIXME: Not sure if this is successfully optimized to a move
-            a
-          }
-          _ { some(b) }
-        }
-    } {
-        some(val) { val }
-        none { fail "min called on empty iterator" }
-    }
-}
-
-fn max<A:copy,IA:iterable<A>>(self: IA) -> A {
-    alt foldl::<A,option<A>,IA>(self, none) {|a, b|
-        alt a {
-          some(a_) if a_ > b {
-            // FIXME: Not sure if this is successfully optimized to a move
-            a
-          }
-          _ { some(b) }
-        }
-    } {
-        some(val) { val }
-        none { fail "max called on empty iterator" }
-    }
-}
 
 #[test]
 fn test_enumerate() {
@@ -222,45 +168,4 @@ fn test_repeat() {
     assert c == [0u, 1u, 4u, 9u, 16u];
 }
 
-#[test]
-fn test_min() {
-    assert min([5, 4, 1, 2, 3]) == 1;
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_min_empty() {
-    min::<int, [int]>([]);
-}
-
-#[test]
-fn test_max() {
-    assert max([1, 2, 4, 2, 3]) == 4;
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_max_empty() {
-    max::<int, [int]>([]);
-}
 
-#[test]
-fn test_reverse() {
-    assert to_list(bind reverse([1, 2, 3], _)) == [3, 2, 1];
-}
-
-#[test]
-fn test_count() {
-    assert count([1, 2, 1, 2, 1], 1) == 3u;
-}
-
-#[test]
-fn test_foldr() {
-    fn sub(&&a: int, -b: int) -> int {
-        a - b
-    }
-    let sum = foldr([1, 2, 3, 4], 0, sub);
-    assert sum == -2;
-}

branches/try/src/libcore/str.rs

@@ -213,16 +213,16 @@ Function: from_cstr_len
 Create a Rust string from a C string of the given length
 */
 unsafe fn from_cstr_len(cstr: sbuf, len: uint) -> str {
-    let res = [];
-    let start = cstr;
-    let curr = start;
-    let i = 0u;
-    while i < len {
-        vec::push(res, *curr);
-        i += 1u;
-        curr = ptr::offset(start, i);
-    }
-    ret from_bytes(res);
+    let buf: [u8] = [];
+    vec::reserve(buf, len + 1u);
+    vec::as_buf(buf) {|b| ptr::memcpy(b, cstr, len); }
+    vec::unsafe::set_len(buf, len);
+    buf += [0u8];
+
+    assert is_utf8(buf);
+    let s: str = ::unsafe::reinterpret_cast(buf);
+    ::unsafe::leak(buf);
+    ret s;
 }
 
 /*