---

yaml
---
r: 62845
b: refs/heads/snap-stage3
c: 8eb358b
h: refs/heads/master
i:
  62843: 0613019
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 395685079a2ef21c93a90ff6ccac2873b3013c7f
+refs/heads/snap-stage3: 8eb358bb00f161f9e289de6cad8cfecc4c6eb681
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/rust.md

@@ -1840,7 +1840,6 @@ is bounds-checked at run-time. When the check fails, it will put the
 task in a _failing state_.
 
 ~~~~
-# use std::task;
 # do task::spawn_unlinked {
 
 ([1, 2, 3, 4])[0];
@@ -2169,7 +2168,7 @@ fn ten_times(f: &fn(int)) {
     }
 }
 
-ten_times(|j| println(fmt!("hello, %d", j)));
+ten_times(|j| io::println(fmt!("hello, %d", j)));
 
 ~~~~
 
@@ -2190,7 +2189,7 @@ An example:
 let mut i = 0;
 
 while i < 10 {
-    println("hello\n");
+    io::println("hello\n");
     i = i + 1;
 }
 ~~~~
@@ -2336,7 +2335,6 @@ for v.each |e| {
 An example of a for loop over a series of integers:
 
 ~~~~
-# use std::uint;
 # fn bar(b:uint) { }
 for uint::range(0, 256) |i| {
     bar(i);
@@ -2800,7 +2798,6 @@ the vtable pointer for the `T` implementation of `R`, and the pointer value of `
 An example of an object type:
 
 ~~~~~~~~
-# use std::int;
 trait Printable {
   fn to_str(&self) -> ~str;
 }
@@ -2810,7 +2807,7 @@ impl Printable for int {
 }
 
 fn print(a: @Printable) {
-   println(a.to_str());
+   io::println(a.to_str());
 }
 
 fn main() {

branches/snap-stage3/doc/tutorial-ffi.md

@@ -149,9 +149,7 @@ A type with the same functionality as owned boxes can be implemented by
 wrapping `malloc` and `free`:
 
 ~~~~
-use std::cast;
 use std::libc::{c_void, size_t, malloc, free};
-use std::ptr;
 use std::unstable::intrinsics;
 use std::util;
 

branches/snap-stage3/doc/tutorial-tasks.md

@@ -120,7 +120,6 @@ should interleave the output in vaguely random order.
 ~~~
 # use std::io::print;
 # use std::task::spawn;
-# use std::int;
 
 for int::range(0, 20) |child_task_number| {
     do spawn {
@@ -237,7 +236,6 @@ Instead we can use a `SharedChan`, a type that allows a single
 ~~~
 # use std::task::spawn;
 # use std::comm::{stream, SharedChan};
-# use std::uint;
 
 let (port, chan) = stream();
 let chan = SharedChan::new(chan);
@@ -271,7 +269,6 @@ might look like the example below.
 ~~~
 # use std::task::spawn;
 # use std::comm::stream;
-# use std::vec;
 
 // Create a vector of ports, one for each child task
 let ports = do vec::from_fn(3) |init_val| {
@@ -313,8 +310,6 @@ the future needs to be mutable so that it can save the result for next time `get
 Here is another example showing how futures allow you to background computations. The workload will
 be distributed on the available cores.
 ~~~
-# use std::vec;
-# use std::uint;
 fn partial_sum(start: uint) -> f64 {
     let mut local_sum = 0f64;
     for uint::range(start*100000, (start+1)*100000) |num| {
@@ -348,17 +343,14 @@ acts as a reference to the shared data and only this reference is shared and clo
 Here is a small example showing how to use ARCs. We wish to run concurrently several computations on
 a single large vector of floats. Each task needs the full vector to perform its duty.
 ~~~
-# use std::vec;
-# use std::uint;
-# use std::rand;
 use extra::arc::ARC;
 
 fn pnorm(nums: &~[float], p: uint) -> float {
     (vec::foldl(0.0, *nums, |a,b| a+(*b).pow(p as float) )).pow(1f / (p as float))
 }
 
 fn main() {
-    let numbers = vec::from_fn(1000000, |_| rand::random::<float>());
+    let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
     println(fmt!("Inf-norm = %?",  numbers.max()));
 
     let numbers_arc = ARC(numbers);
@@ -381,16 +373,12 @@ at the power given as argument and takes the inverse power of this value). The A
 created by the line
 ~~~
 # use extra::arc::ARC;
-# use std::vec;
-# use std::rand;
-# let numbers = vec::from_fn(1000000, |_| rand::random::<float>());
+# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
 let numbers_arc=ARC(numbers);
 ~~~
 and a clone of it is sent to each task
 ~~~
 # use extra::arc::ARC;
-# use std::vec;
-# use std::rand;
 # let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
 # let numbers_arc = ARC(numbers);
 # let (port, chan)  = stream();
@@ -401,8 +389,6 @@ copying only the wrapper and not its contents.
 Each task recovers the underlying data by
 ~~~
 # use extra::arc::ARC;
-# use std::vec;
-# use std::rand;
 # let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
 # let numbers_arc=ARC(numbers);
 # let (port, chan)  = stream();
@@ -430,7 +416,6 @@ of all tasks are intertwined: if one fails, so do all the others.
 
 ~~~
 # use std::task::spawn;
-# use std::task;
 # fn do_some_work() { loop { task::yield() } }
 # do task::try {
 // Create a child task that fails
@@ -452,7 +437,6 @@ field (representing a successful result) or an `Err` result (representing
 termination with an error).
 
 ~~~
-# use std::task;
 # fn some_condition() -> bool { false }
 # fn calculate_result() -> int { 0 }
 let result: Result<int, ()> = do task::try {
@@ -495,7 +479,6 @@ By default, task failure is _bidirectionally linked_, which means that if
 either task fails, it kills the other one.
 
 ~~~
-# use std::task;
 # fn sleep_forever() { loop { task::yield() } }
 # do task::try {
 do spawn {
@@ -518,7 +501,6 @@ before returning. Hence:
 ~~~
 # use std::comm::{stream, Chan, Port};
 # use std::task::{spawn, try};
-# use std::task;
 # fn sleep_forever() { loop { task::yield() } }
 # do task::try {
 let (receiver, sender): (Port<int>, Chan<int>) = stream();
@@ -546,7 +528,6 @@ Supervised task failure propagates across multiple generations even if
 an intermediate generation has already exited:
 
 ~~~
-# use std::task;
 # fn sleep_forever() { loop { task::yield() } }
 # fn wait_for_a_while() { for 1000.times { task::yield() } }
 # do task::try::<int> {
@@ -565,7 +546,6 @@ Finally, tasks can be configured to not propagate failure to each
 other at all, using `task::spawn_unlinked` for _isolated failure_.
 
 ~~~
-# use std::task;
 # fn random() -> uint { 100 }
 # fn sleep_for(i: uint) { for i.times { task::yield() } }
 # do task::try::<()> {
@@ -594,7 +574,6 @@ Here is the function that implements the child task:
 
 ~~~~
 # use extra::comm::DuplexStream;
-# use std::uint;
 fn stringifier(channel: &DuplexStream<~str, uint>) {
     let mut value: uint;
     loop {
@@ -617,7 +596,6 @@ Here is the code for the parent task:
 
 ~~~~
 # use std::task::spawn;
-# use std::uint;
 # use extra::comm::DuplexStream;
 # fn stringifier(channel: &DuplexStream<~str, uint>) {
 #     let mut value: uint;

branches/snap-stage3/doc/tutorial.md

@@ -502,7 +502,6 @@ types.
 > items.
 
 ~~~~
-# use std::float;
 fn angle(vector: (float, float)) -> float {
     let pi = float::consts::pi;
     match vector {
@@ -557,7 +556,6 @@ while cake_amount > 0 {
 `loop` denotes an infinite loop, and is the preferred way of writing `while true`:
 
 ~~~~
-# use std::int;
 let mut x = 5;
 loop {
     x += x - 3;
@@ -701,7 +699,6 @@ get at their contents. All variant constructors can be used as
 patterns, as in this definition of `area`:
 
 ~~~~
-# use std::float;
 # struct Point {x: float, y: float}
 # enum Shape { Circle(Point, float), Rectangle(Point, Point) }
 fn area(sh: Shape) -> float {
@@ -1832,7 +1829,6 @@ vector consisting of the result of applying `function` to each element
 of `vector`:
 
 ~~~~
-# use std::vec;
 fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] {
     let mut accumulator = ~[];
     for vec::each(vector) |element| {
@@ -2030,7 +2026,6 @@ themselves contain type parameters. A trait for generalized sequence
 types might look like the following:
 
 ~~~~
-# use std::vec;
 trait Seq<T> {
     fn len(&self) -> uint;
     fn iter(&self, b: &fn(v: &T));

branches/snap-stage3/src/compiletest/compiletest.rc

@@ -16,13 +16,13 @@
 #[no_std];
 
 extern mod core(name = "std", vers = "0.7-pre");
-extern mod extra(name = "extra", vers = "0.7-pre");
+extern mod std(name = "extra", vers = "0.7-pre");
 
 use core::prelude::*;
 use core::*;
 
-use extra::getopts;
-use extra::test;
+use std::getopts;
+use std::test;
 
 use core::result::{Ok, Err};
 
@@ -42,13 +42,6 @@ pub mod runtest;
 pub mod common;
 pub mod errors;
 
-mod std {
-    pub use core::cmp;
-    pub use core::str;
-    pub use core::sys;
-    pub use core::unstable;
-}
-
 pub fn main() {
     let args = os::args();
     let config = parse_config(args);

branches/snap-stage3/src/compiletest/errors.rs

@@ -10,9 +10,6 @@
 
 use core::prelude::*;
 
-use core::io;
-use core::str;
-
 pub struct ExpectedError { line: uint, kind: ~str, msg: ~str }
 
 // Load any test directives embedded in the file

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

@@ -10,12 +10,8 @@
 
 use core::prelude::*;
 
-use common::config;
 use common;
-
-use core::io;
-use core::os;
-use core::str;
+use common::config;
 
 pub struct TestProps {
     // Lines that should be expected, in order, on standard out

branches/snap-stage3/src/compiletest/procsrv.rs

@@ -10,13 +10,7 @@
 
 use core::prelude::*;
 
-use core::comm;
-use core::io;
-use core::libc::c_int;
-use core::os;
 use core::run;
-use core::str;
-use core::task;
 
 #[cfg(target_os = "win32")]
 fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {

branches/snap-stage3/src/compiletest/runtest.rs

@@ -22,12 +22,6 @@ use procsrv;
 use util;
 use util::logv;
 
-use core::io;
-use core::os;
-use core::str;
-use core::uint;
-use core::vec;
-
 pub fn run(config: config, testfile: ~str) {
     if config.verbose {
         // We're going to be dumping a lot of info. Start on a new line.

branches/snap-stage3/src/compiletest/util.rs

@@ -12,7 +12,6 @@ use core::prelude::*;
 
 use common::config;
 
-use core::io;
 use core::os::getenv;
 
 pub fn make_new_path(path: &str) -> ~str {

branches/snap-stage3/src/etc/combine-tests.py

@@ -53,7 +53,6 @@ def scrub(b):
 d.write("extern mod run_pass_stage2;\n")
 d.write("use run_pass_stage2::*;\n")
 d.write("use std::io::WriterUtil;\n");
-d.write("use std::io;\n");
 d.write("fn main() {\n");
 d.write("    let out = io::stdout();\n");
 i = 0