---

yaml
---
r: 32886
b: refs/heads/dist-snap
c: ca44556
h: refs/heads/master
v: v3

Author: z0w0

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 1b3086aada92337fc02fc276145df391913a798b
+refs/heads/dist-snap: ca4455666eaf09debf6fe769ba75f90453832981
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/doc/tutorial.md

@@ -616,7 +616,7 @@ literals and most enum variants.
 
 `while` produces a loop that runs as long as its given condition
 (which must have type `bool`) evaluates to true. Inside a loop, the
-keyword `break` can be used to abort the loop, and `loop` can be used
+keyword `break` can be used to abort the loop, and `again` can be used
 to abort the current iteration and continue with the next.
 
 ~~~~
@@ -1564,7 +1564,7 @@ Empty argument lists can be omitted from `do` expressions.
 
 Most iteration in Rust is done with `for` loops. Like `do`,
 `for` is a nice syntax for doing control flow with closures.
-Additionally, within a `for` loop, `break`, `loop`, and `return`
+Additionally, within a `for` loop, `break`, `again`, and `return`
 work just as they do with `while` and `loop`.
 
 Consider again our `each` function, this time improved to
@@ -1599,7 +1599,7 @@ With `for`, functions like `each` can be treated more
 like builtin looping structures. When calling `each`
 in a `for` loop, instead of returning `false` to break
 out of the loop, you just write `break`. To skip ahead
-to the next iteration, write `loop`.
+to the next iteration, write `again`.
 
 ~~~~
 # use each = vec::each;

branches/dist-snap/src/compiletest/compiletest.rs

@@ -58,7 +58,7 @@ fn parse_config(args: ~[~str]) -> config {
              } else { option::None },
          logfile: option::map(&getopts::opt_maybe_str(matches,
                                                      ~"logfile"),
-                              |s| Path(*s)),
+                              |s| Path(s)),
          runtool: getopts::opt_maybe_str(matches, ~"runtool"),
          rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
          jit: getopts::opt_present(matches, ~"jit"),

branches/dist-snap/src/compiletest/header.rs

@@ -103,7 +103,7 @@ fn parse_compile_flags(line: ~str) -> Option<~str> {
 fn parse_exec_env(line: ~str) -> Option<(~str, ~str)> {
     do parse_name_value_directive(line, ~"exec-env").map |nv| {
         // nv is either FOO or FOO=BAR
-        let strs = str::splitn_char(*nv, '=', 1u);
+        let strs = str::splitn_char(nv, '=', 1u);
         match strs.len() {
           1u => (strs[0], ~""),
           2u => (strs[0], strs[1]),

branches/dist-snap/src/libcore/dlist.rs

@@ -275,13 +275,13 @@ impl<T> DList<T> {
     /// Remove a node from the head of the list. O(1).
     fn pop_n() -> Option<DListNode<T>> {
         let hd = self.peek_n();
-        hd.map(|nobe| self.unlink(*nobe));
+        hd.map(|nobe| self.unlink(nobe));
         hd
     }
     /// Remove a node from the tail of the list. O(1).
     fn pop_tail_n() -> Option<DListNode<T>> {
         let tl = self.peek_tail_n();
-        tl.map(|nobe| self.unlink(*nobe));
+        tl.map(|nobe| self.unlink(nobe));
         tl
     }
     /// Get the node at the list's head. O(1).

branches/dist-snap/src/libcore/io.rs

@@ -697,10 +697,8 @@ impl BytesWriter: Writer {
             vec::reserve(&mut buf, count);
             unsafe { vec::raw::set_len(buf, count); }
 
-            {
-                let view = vec::mut_view(buf, self.pos, count);
-                vec::bytes::memcpy(view, v, v_len);
-            }
+            let view = vec::mut_view(buf, self.pos, count);
+            vec::bytes::memcpy(view, v, v_len);
 
             self.pos += v_len;
 

branches/dist-snap/src/libcore/iter.rs

@@ -290,7 +290,7 @@ pure fn from_elem<T: Copy,BT: Buildable<T>>(n_elts: uint, t: T) -> BT {
 pure fn append<T: Copy,IT: BaseIter<T>,BT: Buildable<T>>(
     lhs: IT, rhs: IT) -> BT {
     let size_opt = lhs.size_hint().chain(
-        |sz1| rhs.size_hint().map(|sz2| sz1+*sz2));
+        |sz1| rhs.size_hint().map(|sz2| sz1+sz2));
     do build_sized_opt(size_opt) |push| {
         for lhs.each |x| { push(*x); }
         for rhs.each |x| { push(*x); }

branches/dist-snap/src/libcore/option.rs

@@ -61,7 +61,13 @@ pure fn expect<T: Copy>(opt: &Option<T>, +reason: ~str) -> T {
     match *opt { Some(x) => x, None => fail reason }
 }
 
-pure fn map<T, U>(opt: &Option<T>, f: fn(x: &T) -> U) -> Option<U> {
+pure fn map<T, U>(opt: &Option<T>, f: fn(T) -> U) -> Option<U> {
+    //! Maps a `some` value from one type to another
+
+    match *opt { Some(x) => Some(f(x)), None => None }
+}
+
+pure fn map_ref<T, U>(opt: &Option<T>, f: fn(x: &T) -> U) -> Option<U> {
     //! Maps a `some` value by reference from one type to another
 
     match *opt { Some(ref x) => Some(f(x)), None => None }
@@ -132,7 +138,14 @@ pure fn get_default<T: Copy>(opt: &Option<T>, +def: T) -> T {
     match *opt { Some(x) => x, None => def }
 }
 
-pure fn map_default<T, U>(opt: &Option<T>, +def: U,
+pure fn map_default<T, U>(opt: &Option<T>, +def: U, f: fn(T) -> U) -> U {
+    //! Applies a function to the contained value or returns a default
+
+    match *opt { None => move def, Some(t) => f(t) }
+}
+
+// This should replace map_default.
+pure fn map_default_ref<T, U>(opt: &Option<T>, +def: U,
                               f: fn(x: &T) -> U) -> U {
     //! Applies a function to the contained value or returns a default
 
@@ -187,12 +200,17 @@ impl<T> Option<T> {
      * function that returns an option.
      */
     pure fn chain<U>(f: fn(T) -> Option<U>) -> Option<U> { chain(&self, f) }
+    /// Applies a function to the contained value or returns a default
+    pure fn map_default<U>(+def: U, f: fn(T) -> U) -> U
+        { map_default(&self, move def, f) }
     /// Performs an operation on the contained value or does nothing
     pure fn iter(f: fn(T)) { iter(&self, f) }
     /// Returns true if the option equals `none`
     pure fn is_none() -> bool { is_none(&self) }
     /// Returns true if the option contains some value
     pure fn is_some() -> bool { is_some(&self) }
+    /// Maps a `some` value from one type to another
+    pure fn map<U>(f: fn(T) -> U) -> Option<U> { map(&self, f) }
 }
 
 impl<T> &Option<T> {
@@ -204,12 +222,12 @@ impl<T> &Option<T> {
         chain_ref(self, f)
     }
     /// Applies a function to the contained value or returns a default
-    pure fn map_default<U>(+def: U, f: fn(x: &T) -> U) -> U
-        { map_default(self, move def, f) }
+    pure fn map_default_ref<U>(+def: U, f: fn(x: &T) -> U) -> U
+        { map_default_ref(self, move def, f) }
     /// Performs an operation on the contained value by reference
     pure fn iter_ref(f: fn(x: &T)) { iter_ref(self, f) }
     /// Maps a `some` value from one type to another by reference
-    pure fn map<U>(f: fn(x: &T) -> U) -> Option<U> { map(self, f) }
+    pure fn map_ref<U>(f: fn(x: &T) -> U) -> Option<U> { map_ref(self, f) }
     /// Gets an immutable reference to the value inside a `some`.
     pure fn get_ref() -> &self/T { get_ref(self) }
 }

branches/dist-snap/src/libcore/os.rs

@@ -439,7 +439,7 @@ fn self_exe_path() -> Option<Path> {
     }
 
     do load_self().map |pth| {
-        Path(*pth).dir_path()
+        Path(pth).dir_path()
     }
 }
 

branches/dist-snap/src/libcore/str.rs

@@ -1827,10 +1827,10 @@ const tag_six_b: uint = 252u;
  * let i = str::as_bytes("Hello World") { |bytes| vec::len(bytes) };
  * ~~~
  */
-pure fn as_bytes<T>(s: &const ~str, f: fn((&~[u8])) -> T) -> T {
+pure fn as_bytes<T>(s: &const ~str, f: fn(~[u8]) -> T) -> T {
     unsafe {
         let v: *~[u8] = cast::transmute(copy s);
-        f(&*v)
+        f(*v)
     }
 }
 
@@ -1945,7 +1945,7 @@ fn reserve_at_least(s: &const ~str, n: uint) {
  */
 pure fn capacity(s: &const ~str) -> uint {
     do as_bytes(s) |buf| {
-        let vcap = vec::capacity(*buf);
+        let vcap = vec::capacity(buf);
         assert vcap > 0u;
         vcap - 1u
     }
@@ -2037,7 +2037,7 @@ mod raw {
 
     /// Form a slice from a *u8 buffer of the given length without copying.
     unsafe fn buf_as_slice<T>(buf: *u8, len: uint,
-                              f: fn(v: &str) -> T) -> T {
+                              f: fn(&&v: &str) -> T) -> T {
         let v = (buf, len + 1);
         assert is_utf8(::cast::reinterpret_cast(&v));
         f(::cast::transmute(move v))

branches/dist-snap/src/libcore/task/local_data_priv.rs

@@ -75,8 +75,8 @@ unsafe fn local_data_lookup<T: Owned>(
     );
     do map_pos.map |index| {
         // .get() is guaranteed because of "None { false }" above.
-        let (_, data_ptr, _) = (*map)[*index].get();
-        (*index, data_ptr)
+        let (_, data_ptr, _) = (*map)[index].get();
+        (index, data_ptr)
     }
 }
 
@@ -91,7 +91,7 @@ unsafe fn local_get_helper<T: Owned>(
         // was referenced in the local_data box, though, not here, so before
         // overwriting the local_data_box we need to give an extra reference.
         // We must also give an extra reference when not removing.
-        let (index, data_ptr) = *result;
+        let (index, data_ptr) = result;
         let data: @T = cast::transmute(move data_ptr);
         cast::bump_box_refcount(data);
         if do_pop {

branches/dist-snap/src/libcore/task/spawn.rs

@@ -200,7 +200,7 @@ fn each_ancestor(list:        &mut AncestorList,
         // the end of the list, which doesn't make sense to coalesce.
         return do (**ancestors).map_default((None,false)) |ancestor_arc| {
             // NB: Takes a lock! (this ancestor node)
-            do access_ancestors(ancestor_arc) |nobe| {
+            do access_ancestors(&ancestor_arc) |nobe| {
                 // Check monotonicity
                 assert last_generation > nobe.generation;
                 /*##########################################################*

branches/dist-snap/src/libcore/vec.rs

@@ -338,7 +338,7 @@ pure fn slice<T: Copy>(v: &[const T], start: uint, end: uint) -> ~[T] {
 }
 
 /// Return a slice that points into another slice.
-pure fn view<T>(v: &r/[T], start: uint, end: uint) -> &r/[T] {
+pure fn view<T>(v: &[T], start: uint, end: uint) -> &[T] {
     assert (start <= end);
     assert (end <= len(v));
     do as_imm_buf(v) |p, _len| {
@@ -351,7 +351,7 @@ pure fn view<T>(v: &r/[T], start: uint, end: uint) -> &r/[T] {
 }
 
 /// Return a slice that points into another slice.
-pure fn mut_view<T>(v: &r/[mut T], start: uint, end: uint) -> &r/[mut T] {
+pure fn mut_view<T>(v: &[mut T], start: uint, end: uint) -> &[mut T] {
     assert (start <= end);
     assert (end <= len(v));
     do as_mut_buf(v) |p, _len| {
@@ -364,8 +364,7 @@ pure fn mut_view<T>(v: &r/[mut T], start: uint, end: uint) -> &r/[mut T] {
 }
 
 /// Return a slice that points into another slice.
-pure fn const_view<T>(v: &r/[const T], start: uint,
-                      end: uint) -> &r/[const T] {
+pure fn const_view<T>(v: &[const T], start: uint, end: uint) -> &[const T] {
     assert (start <= end);
     assert (end <= len(v));
     do as_const_buf(v) |p, _len| {
@@ -970,7 +969,7 @@ pure fn find<T: Copy>(v: &[T], f: fn(T) -> bool) -> Option<T> {
  */
 pure fn find_between<T: Copy>(v: &[T], start: uint, end: uint,
                       f: fn(T) -> bool) -> Option<T> {
-    position_between(v, start, end, f).map(|i| v[*i])
+    position_between(v, start, end, f).map(|i| v[i])
 }
 
 /**
@@ -993,7 +992,7 @@ pure fn rfind<T: Copy>(v: &[T], f: fn(T) -> bool) -> Option<T> {
  */
 pure fn rfind_between<T: Copy>(v: &[T], start: uint, end: uint,
                                f: fn(T) -> bool) -> Option<T> {
-    rposition_between(v, start, end, f).map(|i| v[*i])
+    rposition_between(v, start, end, f).map(|i| v[i])
 }
 
 /// Find the first index containing a matching value
@@ -1527,7 +1526,6 @@ impl<T: Copy> &[const T]: CopyableVector<T> {
 }
 
 trait ImmutableVector<T> {
-    pure fn view(start: uint, end: uint) -> &self/[T];
     pure fn foldr<U: Copy>(z: U, p: fn(T, U) -> U) -> U;
     pure fn map<U>(f: fn(v: &T) -> U) -> ~[U];
     pure fn mapi<U>(f: fn(uint, v: &T) -> U) -> ~[U];
@@ -1546,10 +1544,6 @@ trait ImmutableEqVector<T: Eq> {
 
 /// Extension methods for vectors
 impl<T> &[T]: ImmutableVector<T> {
-    /// Return a slice that points into another slice.
-    pure fn view(start: uint, end: uint) -> &self/[T] {
-        view(self, start, end)
-    }
     /// Reduce a vector from right to left
     #[inline]
     pure fn foldr<U: Copy>(z: U, p: fn(T, U) -> U) -> U { foldr(self, z, p) }
@@ -2810,14 +2804,17 @@ mod tests {
         assert capacity(v) == 10u;
     }
 
+/*
     #[test]
+    #[ignore] // region inference doesn't work well enough for this yet.
     fn test_view() {
         let v = ~[1, 2, 3, 4, 5];
-        let v = v.view(1u, 3u);
+        let v = view(v, 1u, 3u);
         assert(len(v) == 2u);
         assert(v[0] == 2);
         assert(v[1] == 3);
     }
+*/
 }
 
 // Local Variables:

branches/dist-snap/src/libsyntax/diagnostic.rs

@@ -262,7 +262,7 @@ fn highlight_lines(cm: codemap::codemap, sp: span,
 fn print_macro_backtrace(cm: codemap::codemap, sp: span) {
     do option::iter(&sp.expn_info) |ei| {
         let ss = option::map_default(&ei.callie.span, @~"",
-                                     |span| @codemap::span_to_str(*span, cm));
+                                     |span| @codemap::span_to_str(span, cm));
         print_diagnostic(*ss, note,
                          fmt!("in expansion of #%s", ei.callie.name));
         let ss = codemap::span_to_str(ei.call_site, cm);