---

yaml
---
r: 140715
b: refs/heads/try2
c: 4958e9b
h: refs/heads/master
i:
  140713: 26ef801
  140711: abc5ad1
v: v3

Author: huonw

[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: 82164a1e45ab8155bb9716a850a68fa3212f7fb5
+refs/heads/try2: 4958e9b4b632b67050dc4de6df1f97329292dfbc
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -1946,6 +1946,35 @@ fn avg(v: &[float]) -> float {
 }
 ~~~~
 
+#### Swap expressions
+
+A _swap expression_ consists of an [lvalue](#lvalues-rvalues-and-temporaries) followed by a bi-directional arrow (`<->`) and another [lvalue](#lvalues-rvalues-and-temporaries).
+
+Evaluating a swap expression causes, as a side effect, the values held in the left-hand-side and right-hand-side [lvalues](#lvalues-rvalues-and-temporaries) to be exchanged indivisibly.
+
+Evaluating a swap expression neither changes reference counts,
+nor deeply copies any owned structure pointed to by the moved [rvalue](#lvalues-rvalues-and-temporaries).
+Instead, the swap expression represents an indivisible *exchange of ownership*,
+between the right-hand-side and the left-hand-side of the expression.
+No allocation or destruction is entailed.
+
+An example of three different swap expressions:
+
+~~~~~~~~
+# let mut x = &mut [0];
+# let mut a = &mut [0];
+# let i = 0;
+# struct S1 { z: int };
+# struct S2 { c: int };
+# let mut y = S1{z: 0};
+# let mut b = S2{c: 0};
+
+x <-> a;
+x[i] <-> a[i];
+y.z <-> b.c;
+~~~~~~~~
+
+
 #### Assignment expressions
 
 An _assignment expression_ consists of an [lvalue](#lvalues-rvalues-and-temporaries) expression followed by an
@@ -1986,7 +2015,7 @@ as
 == !=
 &&
 ||
-=
+= <->
 ~~~~
 
 Operators at the same precedence level are evaluated left-to-right.

branches/try2/doc/tutorial-ffi.md

@@ -151,7 +151,6 @@ wrapping `malloc` and `free`:
 ~~~~
 use core::libc::{c_void, size_t, malloc, free};
 use core::unstable::intrinsics;
-use core::util;
 
 // a wrapper around the handle returned by the foreign code
 pub struct Unique<T> {
@@ -185,8 +184,7 @@ impl<T: Owned> Drop for Unique<T> {
     fn finalize(&self) {
         unsafe {
             let mut x = intrinsics::init(); // dummy value to swap in
-            // moving the object out is needed to call the destructor
-            util::replace_ptr(self.ptr, x);
+            x <-> *self.ptr; // moving the object out is needed to call the destructor
             free(self.ptr as *c_void)
         }
     }

branches/try2/doc/tutorial.md

@@ -129,7 +129,7 @@ we have a file `hello.rs` containing this program:
 
 ~~~~
 fn main() {
-    println("hello?");
+    io::println("hello?");
 }
 ~~~~
 
@@ -139,12 +139,12 @@ Windows) which, upon running, will likely do exactly what you expect.
 
 The Rust compiler tries to provide useful information when it encounters an
 error. If you introduce an error into the program (for example, by changing
-`println` to some nonexistent function), and then compile it, you'll see
+`io::println` to some nonexistent function), and then compile it, you'll see
 an error message like this:
 
 ~~~~ {.notrust}
-hello.rs:2:4: 2:16 error: unresolved name: print_with_unicorns
-hello.rs:2     print_with_unicorns("hello?");
+hello.rs:2:4: 2:16 error: unresolved name: io::print_with_unicorns
+hello.rs:2     io::print_with_unicorns("hello?");
                ^~~~~~~~~~~~~~~~~~~~~~~
 ~~~~
 
@@ -227,7 +227,7 @@ let hi = "hi";
 let mut count = 0;
 
 while count < 10 {
-    println(fmt!("count: %?", count));
+    io::println(fmt!("count: %?", count));
     count += 1;
 }
 ~~~~
@@ -400,10 +400,10 @@ don't match the types of the arguments.
 ~~~~
 # let mystery_object = ();
 
-println(fmt!("%s is %d", "the answer", 43));
+io::println(fmt!("%s is %d", "the answer", 43));
 
 // %? will conveniently print any type
-println(fmt!("what is this thing: %?", mystery_object));
+io::println(fmt!("what is this thing: %?", mystery_object));
 ~~~~
 
 [pf]: http://en.cppreference.com/w/cpp/io/c/fprintf
@@ -422,11 +422,11 @@ compulsory, an `if` can have an optional `else` clause, and multiple
 
 ~~~~
 if false {
-    println("that's odd");
+    io::println("that's odd");
 } else if true {
-    println("right");
+    io::println("right");
 } else {
-    println("neither true nor false");
+    io::println("neither true nor false");
 }
 ~~~~
 
@@ -454,10 +454,10 @@ executes its corresponding arm.
 ~~~~
 # let my_number = 1;
 match my_number {
-  0     => println("zero"),
-  1 | 2 => println("one or two"),
-  3..10 => println("three to ten"),
-  _     => println("something else")
+  0     => io::println("zero"),
+  1 | 2 => io::println("one or two"),
+  3..10 => io::println("three to ten"),
+  _     => io::println("something else")
 }
 ~~~~
 
@@ -483,8 +483,8 @@ commas are optional.
 ~~~
 # let my_number = 1;
 match my_number {
-  0 => { println("zero") }
-  _ => { println("something else") }
+  0 => { io::println("zero") }
+  _ => { io::println("something else") }
 }
 ~~~
 
@@ -560,7 +560,7 @@ let mut x = 5;
 loop {
     x += x - 3;
     if x % 5 == 0 { break; }
-    println(int::to_str(x));
+    io::println(int::to_str(x));
 }
 ~~~~
 
@@ -614,8 +614,8 @@ origin.y += 1.0; // ERROR: assigning to immutable field
 # struct Point { x: float, y: float }
 # let mypoint = Point { x: 0.0, y: 0.0 };
 match mypoint {
-    Point { x: 0.0, y: yy } => { println(yy.to_str());                     }
-    Point { x: xx,  y: yy } => { println(xx.to_str() + " " + yy.to_str()); }
+    Point { x: 0.0, y: yy } => { io::println(yy.to_str());                     }
+    Point { x: xx,  y: yy } => { io::println(xx.to_str() + " " + yy.to_str()); }
 }
 ~~~~
 
@@ -630,7 +630,7 @@ reuses the field name as the binding name.
 # struct Point { x: float, y: float }
 # let mypoint = Point { x: 0.0, y: 0.0 };
 match mypoint {
-    Point { x, _ } => { println(x.to_str()) }
+    Point { x, _ } => { io::println(x.to_str()) }
 }
 ~~~
 
@@ -1231,7 +1231,7 @@ something silly like
 ~~~
 # struct Point { x: float, y: float }
 let point = &@~Point { x: 10f, y: 20f };
-println(fmt!("%f", point.x));
+io::println(fmt!("%f", point.x));
 ~~~
 
 The indexing operator (`[]`) also auto-dereferences.
@@ -1373,6 +1373,7 @@ and [`core::str`]. Here are some examples.
 [`core::str`]: core/str.html
 
 ~~~
+# use core::io::println;
 # enum Crayon {
 #     Almond, AntiqueBrass, Apricot,
 #     Aquamarine, Asparagus, AtomicTangerine,
@@ -1427,6 +1428,7 @@ Rust also supports _closures_, functions that can access variables in
 the enclosing scope.
 
 ~~~~
+# use println = core::io::println;
 fn call_closure_with_ten(b: &fn(int)) { b(10); }
 
 let captured_var = 20;
@@ -1488,7 +1490,7 @@ fn mk_appender(suffix: ~str) -> @fn(~str) -> ~str {
 
 fn main() {
     let shout = mk_appender(~"!");
-    println(shout(~"hey ho, let's go"));
+    io::println(shout(~"hey ho, let's go"));
 }
 ~~~~
 
@@ -1630,6 +1632,7 @@ And using this function to iterate over a vector:
 
 ~~~~
 # use each = core::vec::each;
+# use println = core::io::println;
 each([2, 4, 8, 5, 16], |n| {
     if *n % 2 != 0 {
         println("found odd number!");
@@ -1646,6 +1649,7 @@ to the next iteration, write `loop`.
 
 ~~~~
 # use each = core::vec::each;
+# use println = core::io::println;
 for each([2, 4, 8, 5, 16]) |n| {
     if *n % 2 != 0 {
         println("found odd number!");
@@ -1978,7 +1982,7 @@ struct TimeBomb {
 impl Drop for TimeBomb {
     fn finalize(&self) {
         for old_iter::repeat(self.explosivity) {
-            println("blam!");
+            io::println("blam!");
         }
     }
 }
@@ -2010,11 +2014,11 @@ and `~str`.
 ~~~~
 # trait Printable { fn print(&self); }
 impl Printable for int {
-    fn print(&self) { println(fmt!("%d", *self)) }
+    fn print(&self) { io::println(fmt!("%d", *self)) }
 }
 
 impl Printable for ~str {
-    fn print(&self) { println(*self) }
+    fn print(&self) { io::println(*self) }
 }
 
 # 1.print();
@@ -2303,7 +2307,7 @@ mod farm {
 }
 
 fn main() {
-    println(farm::chicken());
+    io::println(farm::chicken());
 }
 ~~~~
 
@@ -2503,7 +2507,7 @@ pub fn explore() -> &str { "world" }
 ~~~~ {.xfail-test}
 // main.rs
 extern mod world;
-fn main() { println(~"hello " + world::explore()); }
+fn main() { io::println(~"hello " + world::explore()); }
 ~~~~
 
 Now compile and run like this (adjust to your platform if necessary):

branches/try2/src/compiletest/header.rs

@@ -91,7 +91,7 @@ pub fn is_test_ignored(config: config, testfile: &Path) -> bool {
     return false;
 
     fn xfail_target() -> ~str {
-        ~"xfail-" + str::to_owned(os::SYSNAME)
+        ~"xfail-" + str::from_slice(os::SYSNAME)
     }
 }
 

branches/try2/src/compiletest/runtest.rs

@@ -371,7 +371,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
             was_expected = true;
         }
 
-        if !was_expected && is_compiler_error_or_warning(str::to_owned(line)) {
+        if !was_expected && is_compiler_error_or_warning(str::from_slice(line)) {
             fatal_ProcRes(fmt!("unexpected compiler error or warning: '%s'",
                                line),
                           ProcRes);
@@ -596,7 +596,7 @@ fn make_lib_name(config: config, auxfile: &Path, testfile: &Path) -> Path {
 
 fn make_exe_name(config: config, testfile: &Path) -> Path {
     Path(output_base_name(config, testfile).to_str() +
-            str::to_owned(os::EXE_SUFFIX))
+            str::from_slice(os::EXE_SUFFIX))
 }
 
 fn make_run_args(config: config, _props: TestProps, testfile: &Path) ->

branches/try2/src/libcore/cell.rs

@@ -12,7 +12,6 @@
 
 use cast::transmute_mut;
 use prelude::*;
-use util::replace;
 
 /*
 A dynamic, mutable location.
@@ -49,7 +48,9 @@ pub impl<T> Cell<T> {
             fail!(~"attempt to take an empty cell");
         }
 
-        replace(&mut self.value, None).unwrap()
+        let mut value = None;
+        value <-> self.value;
+        value.unwrap()
     }
 
     /// Returns the value, failing if the cell is full.