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

Conflicts:

	src/libstd/future.rs

src/librustdoc/markdown_writer.rs

@@ -283,7 +283,7 @@ pub fn future_writer_factory(
         do task::spawn |move writer_ch| {
             let (writer, future) = future_writer();
             writer_ch.send(move writer);
-            let s = future::get(&future);
+            let s = future.get();
             comm::send(markdown_ch, (page, s));
         }
         writer_po.recv()

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,76 +140,26 @@ 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]
     pub fn test_from_port() {
         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]
@@ -208,50 +168,32 @@ pub mod test {
         assert f.get() == ~"fail";
     }
 
-    #[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]
     #[should_fail]
     #[ignore(cfg(target_os = "win32"))]
     pub fn test_futurefail() {
         let f = spawn(|| fail);
-        let _x: ~str = get(&f);
+        let _x: ~str = f.get();
     }
 
     #[test]
     pub fn test_sendable_future() {
         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;
         }
     }

src/test/bench/msgsend-ring-mutex-arcs.rs

@@ -107,7 +107,7 @@ fn main() {
     thread_ring(0, msg_per_task, option::unwrap(move num_chan), move num_port);
 
     // synchronize
-    for futures.each |f| { future::get(f) };
+    for futures.each |f| { f.get() };
 
     let stop = time::precise_time_s();
 

src/test/bench/msgsend-ring-pipes.rs

@@ -101,7 +101,7 @@ fn main() {
     thread_ring(0, msg_per_task, option::unwrap(move num_chan), move num_port);
 
     // synchronize
-    for futures.each |f| { future::get(f) };
+    for futures.each |f| { f.get() };
 
     let stop = time::precise_time_s();
 

src/test/bench/msgsend-ring-rw-arcs.rs

@@ -108,7 +108,7 @@ fn main() {
     thread_ring(0, msg_per_task, option::unwrap(move num_chan), move num_port);
 
     // synchronize
-    for futures.each |f| { future::get(f) };
+    for futures.each |f| { f.get() };
 
     let stop = time::precise_time_s();