---

yaml
---
r: 139326
b: refs/heads/try2
c: f792d17
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 5011d05db25fd3dfc0a9dc41fd914633ffb85469
+refs/heads/try2: f792d177a493aa3ced268ed4d6815baef5ab8d29
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -441,11 +441,11 @@ expression context, the final namespace qualifier is omitted.
 Two examples of paths with type arguments:
 
 ~~~~
-# use core::hashmap::linear::LinearMap;
+# use std::oldmap;
 # fn f() {
 # fn id<T:Copy>(t: T) -> T { t }
-type t = LinearMap<int,~str>;  // Type arguments used in a type expression
-let x = id::<int>(10);         // Type arguments used in a call expression
+type t = oldmap::HashMap<int,~str>;  // Type arguments used in a type expression
+let x = id::<int>(10);           // Type arguments used in a call expression
 # }
 ~~~~
 

branches/try2/doc/tutorial.md

@@ -1829,8 +1829,8 @@ illegal to copy and pass by value.
 Generic `type`, `struct`, and `enum` declarations follow the same pattern:
 
 ~~~~
-# use core::hashmap::linear::LinearMap;
-type Set<T> = LinearMap<T, ()>;
+# use std::oldmap::HashMap;
+type Set<T> = HashMap<T, ()>;
 
 struct Stack<T> {
     elements: ~[T]

branches/try2/src/compiletest/header.rs

@@ -142,8 +142,7 @@ fn parse_check_line(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 mut strs = ~[];
-        for str::each_splitn_char(*nv, '=', 1u) |s| { strs.push(s.to_owned()); }
+        let strs = str::splitn_char(*nv, '=', 1u);
         match strs.len() {
           1u => (strs[0], ~""),
           2u => (strs[0], strs[1]),

branches/try2/src/compiletest/runtest.rs

@@ -267,7 +267,7 @@ fn run_debuginfo_test(config: config, props: TestProps, testfile: &Path) {
         // check if each line in props.check_lines appears in the
         // output (in order)
         let mut i = 0u;
-        for str::each_line(ProcRes.stdout) |line| {
+        for str::lines_each(ProcRes.stdout) |line| {
             if props.check_lines[i].trim() == line.trim() {
                 i += 1u;
             }
@@ -297,7 +297,7 @@ fn check_error_patterns(props: TestProps,
     let mut next_err_idx = 0u;
     let mut next_err_pat = props.error_patterns[next_err_idx];
     let mut done = false;
-    for str::each_line(ProcRes.stderr) |line| {
+    for str::lines_each(ProcRes.stderr) |line| {
         if str::contains(line, next_err_pat) {
             debug!("found error pattern %s", next_err_pat);
             next_err_idx += 1u;
@@ -347,7 +347,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
     //    filename:line1:col1: line2:col2: *warning:* msg
     // where line1:col1: is the starting point, line2:col2:
     // is the ending point, and * represents ANSI color codes.
-    for str::each_line(ProcRes.stderr) |line| {
+    for str::lines_each(ProcRes.stderr) |line| {
         let mut was_expected = false;
         for vec::eachi(expected_errors) |i, ee| {
             if !found_flags[i] {
@@ -596,12 +596,8 @@ fn split_maybe_args(argstr: Option<~str>) -> ~[~str] {
     }
 
     match argstr {
-        Some(s) => {
-            let mut ss = ~[];
-            for str::each_split_char(s, ' ') |s| { ss.push(s.to_owned()) }
-            rm_whitespace(ss)
-        }
-        None => ~[]
+      Some(s) => rm_whitespace(str::split_char(s, ' ')),
+      None => ~[]
     }
 }
 

branches/try2/src/libcore/cast.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Unsafe casting functions
-
 pub mod rusti {
     #[abi = "rust-intrinsic"]
     #[link_name = "rusti"]

branches/try2/src/libcore/cell.rs

@@ -8,17 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! A mutable, nullable memory location
-
 use cast::transmute;
 use option;
 use prelude::*;
 
-/*
-A dynamic, mutable location.
-
-Similar to a mutable option type, but friendlier.
-*/
+/// A dynamic, mutable location.
+///
+/// Similar to a mutable option type, but friendlier.
 
 pub struct Cell<T> {
     mut value: Option<T>

branches/try2/src/libcore/clone.rs

@@ -8,20 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/*! The Clone trait for types that cannot be "implicitly copied"
-
-In Rust, some simple types are "implicitly copyable" and when you
-assign them or pass them as arguments, the receiver will get a copy,
-leaving the original value in place. These types do not require
-allocation to copy and do not have finalizers (i.e. they do not
-contain owned pointers or implement `Drop`), so the compiler considers
-them cheap and safe to copy and automatically implements the `Copy`
-trait for them. For other types copies must be made explicitly,
-by convention implementing the `Clone` trait and calling the
-`clone` method.
-
+/**
+Clonable types are copied with the clone method
 */
-
 pub trait Clone {
     fn clone(&self) -> Self;
 }

branches/try2/src/libcore/comm.rs

@@ -8,10 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/*!
-Message passing
-*/
-
 use cast;
 use either::{Either, Left, Right};
 use kinds::Owned;

branches/try2/src/libcore/condition.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/*! Condition handling */
-
 use prelude::*;
 use task;
 use task::local_data::{local_data_pop, local_data_set};

branches/try2/src/libcore/core.rc

@@ -10,39 +10,27 @@
 
 /*!
 
-# The Rust core library
+The Rust core library
 
 The Rust core library provides runtime features required by the language,
 including the task scheduler and memory allocators, as well as library
 support for Rust built-in types, platform abstractions, and other commonly
 used features.
 
 `core` includes modules corresponding to each of the integer types, each of
-the floating point types, the `bool` type, tuples, characters, strings
-(`str`), vectors (`vec`), managed boxes (`managed`), owned boxes (`owned`),
-and unsafe and borrowed pointers (`ptr`).  Additionally, `core` provides
-pervasive types (`option` and `result`), task creation and communication
-primitives (`task`, `comm`), platform abstractions (`os` and `path`), basic
-I/O abstractions (`io`), common traits (`kinds`, `ops`, `cmp`, `num`,
-`to_str`), and complete bindings to the C standard library (`libc`).
+the floating point types, the `bool` type, tuples, characters, strings,
+vectors (`vec`), managed boxes (`managed`), owned boxes (`owned`), and unsafe
+and borrowed pointers (`ptr`).  Additionally, `core` provides task management
+and creation (`task`), communication primitives (`comm` and `pipes`), platform
+abstractions (`os` and `path`), basic I/O abstractions (`io`), common traits
+(`cmp`, `num`, `to_str`), and complete bindings to the C standard library
+(`libc`).
 
-# Core injection and the Rust prelude
-
-`core` is imported at the topmost level of every crate by default, as
-if the first line of each crate was
+`core` is linked to all crates by default and its contents imported.
+Implicitly, all crates behave as if they included the following prologue:
 
     extern mod core;
-
-This means that the contents of core can be accessed from from any context
-with the `core::` path prefix, as in `use core::vec`, `use core::task::spawn`,
-etc.
-
-Additionally, `core` contains a `prelude` module that reexports many of the
-most common core modules, types and traits. The contents of the prelude are
-imported inte every *module* by default.  Implicitly, all modules behave as if
-they contained the following prologue:
-
-    use core::prelude::*;
+    use core::*;
 
 */
 

branches/try2/src/libcore/flate.rs

@@ -17,10 +17,10 @@ Simple compression
 use libc;
 use libc::{c_void, size_t, c_int};
 use ptr;
+use rand::RngUtil;
 use vec;
 
 #[cfg(test)] use rand;
-#[cfg(test)] use rand::RngUtil;
 
 pub mod rustrt {
     use libc::{c_int, c_void, size_t};

branches/try2/src/libcore/gc.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[doc(hidden)];
+
 /*! Precise garbage collector
 
 The precise GC exposes two functions, gc and

branches/try2/src/libcore/hashmap.rs

@@ -656,11 +656,6 @@ pub mod linear {
         fn reserve_at_least(&mut self, n: uint) {
             self.map.reserve_at_least(n)
         }
-
-        /// Consumes all of the elements in the set, emptying it out
-        fn consume(&mut self, f: &fn(T)) {
-            self.map.consume(|k, _| f(k))
-        }
     }
 
     #[test]

branches/try2/src/libcore/logging.rs

@@ -10,6 +10,8 @@
 
 //! Logging
 
+use libc;
+
 pub mod rustrt {
     use libc;
 
@@ -47,7 +49,6 @@ pub fn console_off() {
 pub fn log_type<T>(level: u32, object: &T) {
     use cast::transmute;
     use io;
-    use libc;
     use repr;
     use vec;
 

branches/try2/src/libcore/num/strconv.rs

@@ -130,13 +130,6 @@ impl_NumStrConv_Integer!(u16)
 impl_NumStrConv_Integer!(u32)
 impl_NumStrConv_Integer!(u64)
 
-
-// Special value strings as [u8] consts.
-static inf_buf:          [u8*3] = ['i' as u8, 'n' as u8, 'f' as u8];
-static positive_inf_buf: [u8*4] = ['+' as u8, 'i' as u8, 'n' as u8, 'f' as u8];
-static negative_inf_buf: [u8*4] = ['-' as u8, 'i' as u8, 'n' as u8, 'f' as u8];
-static nan_buf:          [u8*3] = ['N' as u8, 'a' as u8, 'N' as u8];
-
 /**
  * Converts a number to its string representation as a byte vector.
  * This is meant to be a common base implementation for all numeric string
@@ -486,15 +479,15 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+Ord+Copy+Div<T,T>+
     }
 
     if special {
-        if buf == inf_buf || buf == positive_inf_buf {
+        if buf == str::inf_buf || buf == str::positive_inf_buf {
             return NumStrConv::inf();
-        } else if buf == negative_inf_buf {
+        } else if buf == str::negative_inf_buf {
             if negative {
                 return NumStrConv::neg_inf();
             } else {
                 return None;
             }
-        } else if buf == nan_buf {
+        } else if buf == str::nan_buf {
             return NumStrConv::NaN();
         }
     }

branches/try2/src/libcore/os.rs

@@ -218,8 +218,7 @@ pub fn env() -> ~[(~str,~str)] {
         fn env_convert(input: ~[~str]) -> ~[(~str, ~str)] {
             let mut pairs = ~[];
             for input.each |p| {
-                let mut vs = ~[];
-                for str::each_splitn_char(*p, '=', 1) |s| { vs.push(s.to_owned()) }
+                let vs = str::splitn_char(*p, '=', 1);
                 debug!("splitting: len: %u",
                     vs.len());
                 fail_unless!(vs.len() == 2);

branches/try2/src/libcore/path.rs

@@ -381,8 +381,7 @@ impl ToStr for PosixPath {
 impl GenericPath for PosixPath {
 
     fn from_str(s: &str) -> PosixPath {
-        let mut components = ~[];
-        for str::each_split_nonempty(s, |c| c == '/') |s| { components.push(s.to_owned()) }
+        let mut components = str::split_nonempty(s, |c| c == '/');
         let is_absolute = (s.len() != 0 && s[0] == '/' as u8);
         return PosixPath { is_absolute: is_absolute,
                            components: components }
@@ -505,10 +504,9 @@ impl GenericPath for PosixPath {
     fn push_many(&self, cs: &[~str]) -> PosixPath {
         let mut v = copy self.components;
         for cs.each |e| {
-            let mut ss = ~[];
-            for str::each_split_nonempty(*e, |c| windows::is_sep(c as u8)) |s| {
-                ss.push(s.to_owned())
-            }
+            let mut ss = str::split_nonempty(
+                *e,
+                |c| windows::is_sep(c as u8));
             unsafe { v.push_all_move(ss); }
         }
         PosixPath { is_absolute: self.is_absolute,
@@ -517,10 +515,7 @@ impl GenericPath for PosixPath {
 
     fn push(&self, s: &str) -> PosixPath {
         let mut v = copy self.components;
-        let mut ss = ~[];
-        for str::each_split_nonempty(s, |c| windows::is_sep(c as u8)) |s| {
-            ss.push(s.to_owned())
-        }
+        let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
         unsafe { v.push_all_move(ss); }
         PosixPath { components: v, ..copy *self }
     }
@@ -595,10 +590,8 @@ impl GenericPath for WindowsPath {
           }
         }
 
-        let mut components = ~[];
-        for str::each_split_nonempty(rest, |c| windows::is_sep(c as u8)) |s| {
-            components.push(s.to_owned())
-        }
+        let mut components =
+            str::split_nonempty(rest, |c| windows::is_sep(c as u8));
         let is_absolute = (rest.len() != 0 && windows::is_sep(rest[0]));
         return WindowsPath { host: host,
                              device: device,
@@ -766,10 +759,9 @@ impl GenericPath for WindowsPath {
     fn push_many(&self, cs: &[~str]) -> WindowsPath {
         let mut v = copy self.components;
         for cs.each |e| {
-            let mut ss = ~[];
-            for str::each_split_nonempty(*e, |c| windows::is_sep(c as u8)) |s| {
-                ss.push(s.to_owned())
-            }
+            let mut ss = str::split_nonempty(
+                *e,
+                |c| windows::is_sep(c as u8));
             unsafe { v.push_all_move(ss); }
         }
         // tedious, but as-is, we can't use ..self
@@ -783,10 +775,7 @@ impl GenericPath for WindowsPath {
 
     fn push(&self, s: &str) -> WindowsPath {
         let mut v = copy self.components;
-        let mut ss = ~[];
-        for str::each_split_nonempty(s, |c| windows::is_sep(c as u8)) |s| {
-            ss.push(s.to_owned())
-        }
+        let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
         unsafe { v.push_all_move(ss); }
         return WindowsPath { components: v, ..copy *self }
     }

branches/try2/src/libcore/prelude.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! The Rust prelude. Imported into every module by default.
+// This file is imported into every module by default.
 
 /* Reexported core operators */
 

branches/try2/src/libcore/rand.rs

@@ -327,9 +327,7 @@ impl RngUtil for @Rng {
      */
     fn gen_char_from(&self, chars: &str) -> char {
         fail_unless!(!chars.is_empty());
-        let mut cs = ~[];
-        for str::each_char(chars) |c| { cs.push(c) }
-        self.choose(cs)
+        self.choose(str::chars(chars))
     }
 
     /// Return a random bool