libstd: refactor future, remove with(), remove ~ indirection.

Conflicts:

	src/libstd/future.rs

1 files changed, 32 insertions, 90 deletions

diff --git a/src/libstd/future.rs b/src/libstd/future.rs
index e0aed60e803..960098c1db6 100644
--- a/src/libstd/future.rs
+++ b/src/libstd/future.rs
@@ -8,11 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// NB: transitionary, de-mode-ing.
-// tjc: allowing deprecated modes due to function issue.
-// can re-forbid them after snapshot
-#[forbid(deprecated_pattern)];
-
 /*!
  * A type representing values that may be computed concurrently and
  * operations for working with them.
@@ -44,27 +39,42 @@ impl<A> Future<A> : Drop {
 priv enum FutureState<A> {
     Pending(fn~() -> A),
     Evaluating,
-    Forced(~A)
+    Forced(A)
 }
 
 /// Methods on the `future` type
 impl<A:Copy> Future<A> {
     fn get() -> A {
         //! Get the value of the future
-
-        get(&self)
+        *(self.get_ref())
     }
 }
 
 impl<A> Future<A> {
-    fn get_ref(&self) -> &self/A {
-        get_ref(self)
-    }
-
-    fn with<B>(blk: fn(&A) -> B) -> B {
-        //! Work with the value without copying it
 
-        with(&self, blk)
+    pure fn get_ref(&self) -> &self/A {
+        /*!
+        * Executes the future's closure and then returns a borrowed
+        * pointer to the result.  The borrowed pointer lasts as long as
+        * the future.
+        */
+        unsafe {
+            match self.state {
+                Forced(ref mut v) => { return cast::transmute(v); }
+                Evaluating => fail ~"Recursive forcing of future!",
+                Pending(_) => {}
+            }
+
+            let mut state = Evaluating;
+            self.state <-> state;
+            match move state {
+                Forced(_) | Evaluating => fail ~"Logic error.",
+                Pending(move f) => {
+                    self.state = Forced(move f());
+                    self.get_ref()
+                }
+            }
+        }
     }
 }
 
@@ -76,7 +86,7 @@ pub fn from_value<A>(val: A) -> Future<A> {
      * not block.
      */
 
-    Future {state: Forced(~(move val))}
+    Future {state: Forced(move val)}
 }
 
 pub fn from_port<A:Send>(port: PortOne<A>) ->
@@ -130,62 +140,12 @@ pub fn spawn<A:Send>(blk: fn~() -> A) -> Future<A> {
     return from_port(move port);
 }
 
-pub fn get_ref<A>(future: &r/Future<A>) -> &r/A {
-    /*!
-     * Executes the future's closure and then returns a borrowed
-     * pointer to the result.  The borrowed pointer lasts as long as
-     * the future.
-     */
-
-    // The unsafety here is to hide the aliases from borrowck, which
-    // would otherwise be concerned that someone might reassign
-    // `future.state` and cause the value of the future to be freed.
-    // But *we* know that once `future.state` is `Forced()` it will
-    // never become "unforced"---so we can safely return a pointer
-    // into the interior of the Forced() variant which will last as
-    // long as the future itself.
-
-    match future.state {
-      Forced(ref v) => { // v here has type &A, but with a shorter lifetime.
-        return unsafe{ copy_lifetime(future, &**v) }; // ...extend it.
-      }
-      Evaluating => {
-        fail ~"Recursive forcing of future!";
-      }
-      Pending(_) => {}
-    }
-
-    let mut state = Evaluating;
-    state <-> future.state;
-    match move state {
-      Forced(_) | Evaluating => {
-        fail ~"Logic error.";
-      }
-      Pending(move f) => {
-        future.state = Forced(~f());
-        return get_ref(future);
-      }
-    }
-}
-
-pub fn get<A:Copy>(future: &Future<A>) -> A {
-    //! Get the value of the future
-
-    *get_ref(future)
-}
-
-pub fn with<A,B>(future: &Future<A>, blk: fn(&A) -> B) -> B {
-    //! Work with the value without copying it
-
-    blk(get_ref(future))
-}
-
 #[allow(non_implicitly_copyable_typarams)]
 pub mod test {
     #[test]
     pub fn test_from_value() {
         let f = from_value(~"snail");
-        assert get(&f) == ~"snail";
+        assert f.get() == ~"snail";
     }
 
     #[test]
@@ -193,13 +153,13 @@ pub mod test {
         let (ch, po) = oneshot::init();
         send_one(move ch, ~"whale");
         let f = from_port(move po);
-        assert get(&f) == ~"whale";
+        assert f.get() == ~"whale";
     }
 
     #[test]
     pub fn test_from_fn() {
         let f = from_fn(|| ~"brail");
-        assert get(&f) == ~"brail";
+        assert f.get() == ~"brail";
     }
 
     #[test]
@@ -209,33 +169,15 @@ pub mod test {
     }
 
     #[test]
-    pub fn test_with() {
-        let f = from_value(~"nail");
-        assert with(&f, |v| copy *v) == ~"nail";
-    }
-
-    #[test]
     pub fn test_get_ref_method() {
         let f = from_value(22);
         assert *f.get_ref() == 22;
     }
 
     #[test]
-    pub fn test_get_ref_fn() {
-        let f = from_value(22);
-        assert *get_ref(&f) == 22;
-    }
-
-    #[test]
-    pub fn test_interface_with() {
-        let f = from_value(~"kale");
-        assert f.with(|v| copy *v) == ~"kale";
-    }
-
-    #[test]
     pub fn test_spawn() {
         let f = spawn(|| ~"bale");
-        assert get(&f) == ~"bale";
+        assert f.get() == ~"bale";
     }
 
     #[test]
@@ -243,7 +185,7 @@ pub mod test {
     #[ignore(cfg(target_os = "win32"))]
     pub fn test_futurefail() {
         let f = spawn(|| fail);
-        let _x: ~str = get(&f);
+        let _x: ~str = f.get();
     }
 
     #[test]
@@ -251,7 +193,7 @@ pub mod test {
         let expected = ~"schlorf";
         let f = do spawn |copy expected| { copy expected };
         do task::spawn |move f, move expected| {
-            let actual = get(&f);
+            let actual = f.get();
             assert actual == expected;
         }
     }