---

yaml
---
r: 59069
b: refs/heads/incoming
c: 4958e9b
h: refs/heads/master
i:
  59067: d7e4b7d
v: v3

Author: huonw

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: 9f106a643e6cdf2f3c8d62bcec61da087ed24c5b
+refs/heads/incoming: 4958e9b4b632b67050dc4de6df1f97329292dfbc
 refs/heads/dist-snap: 00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/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/incoming/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/incoming/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.

branches/incoming/src/libcore/comm.rs

@@ -21,7 +21,6 @@ use uint;
 use unstable;
 use vec;
 use unstable::Exclusive;
-use util::replace;
 
 use pipes::{recv, try_recv, wait_many, peek, PacketHeader};
 
@@ -150,8 +149,9 @@ impl<T: Owned> GenericChan<T> for Chan<T> {
     #[inline(always)]
     fn send(&self, x: T) {
         unsafe {
+            let mut endp = None;
             let mut self_endp = transmute_mut(&self.endp);
-            let endp = replace(self_endp, None);
+            endp <-> *self_endp;
             *self_endp = Some(streamp::client::data(endp.unwrap(), x))
         }
     }
@@ -161,8 +161,9 @@ impl<T: Owned> GenericSmartChan<T> for Chan<T> {
     #[inline(always)]
     fn try_send(&self, x: T) -> bool {
         unsafe {
+            let mut endp = None;
             let mut self_endp = transmute_mut(&self.endp);
-            let endp = replace(self_endp, None);
+            endp <-> *self_endp;
             match streamp::client::try_data(endp.unwrap(), x) {
                 Some(next) => {
                     *self_endp = Some(next);
@@ -178,8 +179,9 @@ impl<T: Owned> GenericPort<T> for Port<T> {
     #[inline(always)]
     fn recv(&self) -> T {
         unsafe {
+            let mut endp = None;
             let mut self_endp = transmute_mut(&self.endp);
-            let endp = replace(self_endp, None);
+            endp <-> *self_endp;
             let streamp::data(x, endp) = recv(endp.unwrap());
             *self_endp = Some(endp);
             x
@@ -189,8 +191,9 @@ impl<T: Owned> GenericPort<T> for Port<T> {
     #[inline(always)]
     fn try_recv(&self) -> Option<T> {
         unsafe {
+            let mut endp = None;
             let mut self_endp = transmute_mut(&self.endp);
-            let endp = replace(self_endp, None);
+            endp <-> *self_endp;
             match try_recv(endp.unwrap()) {
                 Some(streamp::data(x, endp)) => {
                     *self_endp = Some(endp);
@@ -206,13 +209,14 @@ impl<T: Owned> Peekable<T> for Port<T> {
     #[inline(always)]
     fn peek(&self) -> bool {
         unsafe {
+            let mut endp = None;
             let mut self_endp = transmute_mut(&self.endp);
-            let mut endp = replace(self_endp, None);
+            endp <-> *self_endp;
             let peek = match endp {
                 Some(ref mut endp) => peek(endp),
                 None => fail!(~"peeking empty stream")
             };
-            *self_endp = endp;
+            *self_endp <-> endp;
             peek
         }
     }
@@ -263,7 +267,8 @@ impl<T:Owned> GenericPort<T> for PortSet<T> {
             let mut result = None;
             // we have to swap the ports array so we aren't borrowing
             // aliasable mutable memory.
-            let mut ports = replace(self_ports, ~[]);
+            let mut ports = ~[];
+            ports <-> *self_ports;
             while result.is_none() && ports.len() > 0 {
                 let i = wait_many(ports);
                 match ports[i].try_recv() {
@@ -276,7 +281,7 @@ impl<T:Owned> GenericPort<T> for PortSet<T> {
                     }
                 }
             }
-            *self_ports = ports;
+            ports <-> *self_ports;
             result
         }
     }
@@ -315,7 +320,8 @@ impl<T: Owned> GenericChan<T> for SharedChan<T> {
     fn send(&self, x: T) {
         let mut xx = Some(x);
         do self.ch.with_imm |chan| {
-            let x = replace(&mut xx, None);
+            let mut x = None;
+            x <-> xx;
             chan.send(x.unwrap())
         }
     }
@@ -325,7 +331,8 @@ impl<T: Owned> GenericSmartChan<T> for SharedChan<T> {
     fn try_send(&self, x: T) -> bool {
         let mut xx = Some(x);
         do self.ch.with_imm |chan| {
-            let x = replace(&mut xx, None);
+            let mut x = None;
+            x <-> xx;
             chan.try_send(x.unwrap())
         }
     }

branches/incoming/src/libcore/core

@@ -176,13 +176,16 @@ priv impl<K:Hash + Eq,V> HashMap<K, V> {
     /// Expands the capacity of the array and re-insert each of the
     /// existing buckets.
     fn resize(&mut self, new_capacity: uint) {
+        let old_capacity = self.buckets.len();
         self.resize_at = resize_at(new_capacity);
 
-        let old_buckets = replace(&mut self.buckets,
-                                  vec::from_fn(new_capacity, |_| None));
+        let mut old_buckets = vec::from_fn(new_capacity, |_| None);
+        self.buckets <-> old_buckets;
 
         self.size = 0;
-        do vec::consume(old_buckets) |_, bucket| {
+        for uint::range(0, old_capacity) |i| {
+            let mut bucket = None;
+            bucket <-> old_buckets[i];
             self.insert_opt_bucket(bucket);
         }
     }
@@ -262,11 +265,13 @@ priv impl<K:Hash + Eq,V> HashMap<K, V> {
         };
 
         let len_buckets = self.buckets.len();
-        let bucket = replace(&mut self.buckets[idx], None);
+        let mut bucket = None;
+        self.buckets[idx] <-> bucket;
 
         let value = match bucket {
             None => None,
-            Some(Bucket{value, _}) => {
+            Some(bucket) => {
+                let Bucket{value: value, _} = bucket;
                 Some(value)
             },
         };
@@ -276,7 +281,8 @@ priv impl<K:Hash + Eq,V> HashMap<K, V> {
         let size = self.size - 1;
         idx = self.next_bucket(idx, len_buckets);
         while self.buckets[idx].is_some() {
-            let bucket = replace(&mut self.buckets[idx], None);
+            let mut bucket = None;
+            bucket <-> self.buckets[idx];
             self.insert_opt_bucket(bucket);
             idx = self.next_bucket(idx, len_buckets);
         }
@@ -607,13 +613,15 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
     }
 
     fn consume(&mut self, f: &fn(K, V)) {
-        let buckets = replace(&mut self.buckets, ~[]);
+        let mut buckets = ~[];
+        self.buckets <-> buckets;
         self.size = 0;
 
         do vec::consume(buckets) |_, bucket| {
             match bucket {
                 None => {},
-                Some(Bucket{key, value, _}) => {
+                Some(bucket) => {
+                    let Bucket{key: key, value: value, _} = bucket;
                     f(key, value)
                 }
             }

branches/incoming/src/libcore/hashmap.rs

@@ -93,7 +93,6 @@ use unstable::intrinsics;
 use ptr;
 use task;
 use vec;
-use util::replace;
 
 static SPIN_COUNT: uint = 0;
 
@@ -429,7 +428,8 @@ fn try_recv_<T:Owned>(p: &mut Packet<T>) -> Option<T> {
     // optimistic path
     match p.header.state {
       Full => {
-        let payload = replace(&mut p.payload, None);
+        let mut payload = None;
+        payload <-> p.payload;
         p.header.state = Empty;
         return Some(payload.unwrap())
       },
@@ -480,7 +480,8 @@ fn try_recv_<T:Owned>(p: &mut Packet<T>) -> Option<T> {
             fail!(~"blocking on already blocked packet")
           },
           Full => {
-            let payload = replace(&mut p.payload, None);
+            let mut payload = None;
+            payload <-> p.payload;
             let old_task = swap_task(&mut p.header.blocked_task, ptr::null());
             if !old_task.is_null() {
                 unsafe {
@@ -674,7 +675,8 @@ impl<T:Owned,Tbuffer:Owned> Drop for SendPacketBuffered<T,Tbuffer> {
         unsafe {
             let this: &mut SendPacketBuffered<T,Tbuffer> = transmute(self);
             if this.p != None {
-                let p = replace(&mut this.p, None);
+                let mut p = None;
+                p <-> this.p;
                 sender_terminate(p.unwrap())
             }
         }
@@ -693,7 +695,9 @@ pub fn SendPacketBuffered<T,Tbuffer>(p: *mut Packet<T>)
 
 pub impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> {
     fn unwrap(&mut self) -> *mut Packet<T> {
-        replace(&mut self.p, None).unwrap()
+        let mut p = None;
+        p <-> self.p;
+        p.unwrap()
     }
 
     fn header(&mut self) -> *mut PacketHeader {
@@ -709,7 +713,9 @@ pub impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> {
 
     fn reuse_buffer(&mut self) -> BufferResource<Tbuffer> {
         //error!("send reuse_buffer");
-        replace(&mut self.buffer, None).unwrap()
+        let mut tmp = None;
+        tmp <-> self.buffer;
+        tmp.unwrap()
     }
 }
 
@@ -732,7 +738,8 @@ impl<T:Owned,Tbuffer:Owned> Drop for RecvPacketBuffered<T,Tbuffer> {
         unsafe {
             let this: &mut RecvPacketBuffered<T,Tbuffer> = transmute(self);
             if this.p != None {
-                let p = replace(&mut this.p, None);
+                let mut p = None;
+                p <-> this.p;
                 receiver_terminate(p.unwrap())
             }
         }
@@ -741,11 +748,15 @@ impl<T:Owned,Tbuffer:Owned> Drop for RecvPacketBuffered<T,Tbuffer> {
 
 pub impl<T:Owned,Tbuffer:Owned> RecvPacketBuffered<T, Tbuffer> {
     fn unwrap(&mut self) -> *mut Packet<T> {
-        replace(&mut self.p, None).unwrap()
+        let mut p = None;
+        p <-> self.p;
+        p.unwrap()
     }
 
     fn reuse_buffer(&mut self) -> BufferResource<Tbuffer> {
-        replace(&mut self.buffer, None).unwrap()
+        let mut tmp = None;
+        tmp <-> self.buffer;
+        tmp.unwrap()
     }
 }