---

yaml
---
r: 31585
b: refs/heads/dist-snap
c: 9facb15
h: refs/heads/master
i:
  31583: 264aa4d
v: v3

Author: bblum

[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: 7d4742e101f476de072834cb68b6c53dfb59ed07
+refs/heads/dist-snap: 9facb15c49488901e0a1a91af016b9516b5a124f
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -23,7 +23,7 @@ pure fn get<T: copy>(opt: option<T>) -> T {
      * Fails if the value equals `none`
      */
 
-    alt opt { some(x) { return x; } none { fail ~"option none"; } }
+    alt opt { some(x) { return x; } none { fail ~"option::get none"; } }
 }
 
 pure fn expect<T: copy>(opt: option<T>, reason: ~str) -> T {
@@ -112,14 +112,21 @@ pure fn unwrap<T>(-opt: option<T>) -> T {
     unsafe {
         let addr = alt opt {
           some(x) { ptr::addr_of(x) }
-          none { fail ~"option none" }
+          none { fail ~"option::unwrap none" }
         };
         let liberated_value = unsafe::reinterpret_cast(*addr);
         unsafe::forget(opt);
         return liberated_value;
     }
 }
 
+/// The ubiquitous option dance.
+#[inline(always)]
+fn swap_unwrap<T>(opt: &mut option<T>) -> T {
+    if opt.is_none() { fail ~"option::swap_unwrap none" }
+    unwrap(util::replace(opt, none))
+}
+
 pure fn unwrap_expect<T>(-opt: option<T>, reason: ~str) -> T {
     //! As unwrap, but with a specified failure message.
     if opt.is_none() { fail reason; }
@@ -204,6 +211,24 @@ fn test_unwrap_resource() {
     assert *i == 1;
 }
 
+#[test]
+fn test_option_dance() {
+    let x = some(());
+    let mut y = some(5);
+    let mut y2 = 0;
+    do x.iter |_x| {
+        y2 = swap_unwrap(&mut y);
+    }
+    assert y2 == 5;
+    assert y.is_none();
+}
+#[test] #[should_fail] #[ignore(cfg(windows))]
+fn test_option_too_much_dance() {
+    let mut y = some(util::noncopyable());
+    let _y2 = swap_unwrap(&mut y);
+    let _y3 = swap_unwrap(&mut y);
+}
+
 #[test]
 fn test_option_while_some() {
     let mut i = 0;

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

@@ -9,6 +9,7 @@ pure fn id<T>(+x: T) -> T { x }
  * Swap the values at two mutable locations of the same type, without
  * deinitialising or copying either one.
  */
+#[inline(always)]
 fn swap<T>(x: &mut T, y: &mut T) {
     *x <-> *y;
 }
@@ -17,6 +18,7 @@ fn swap<T>(x: &mut T, y: &mut T) {
  * Replace the value at a mutable location with a new one, returning the old
  * value, without deinitialising or copying either one.
  */
+#[inline(always)]
 fn replace<T>(dest: &mut T, +src: T) -> T {
     let mut tmp = src;
     swap(dest, &mut tmp);