---

yaml
---
r: 83272
b: refs/heads/try
c: c767643
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0e4d1fc8cae42e15e00f71d9f439b01bb25a86ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
-refs/heads/try: 407d179f4e0b625e6911ebaf72c87cd35935fb06
+refs/heads/try: c767643f2b7f3b47b98acf424ceaf6826c0475bc
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/tutorial-tasks.md

@@ -280,7 +280,7 @@ fn fib(n: uint) -> uint {
     12586269025
 }
 
-let mut delayed_fib = extra::future::Future::spawn (|| fib(50) );
+let mut delayed_fib = extra::future::spawn (|| fib(50) );
 make_a_sandwich();
 println(fmt!("fib(50) = %?", delayed_fib.get()))
 ~~~
@@ -304,7 +304,7 @@ fn partial_sum(start: uint) -> f64 {
 }
 
 fn main() {
-    let mut futures = vec::from_fn(1000, |ind| do extra::future::Future::spawn { partial_sum(ind) });
+    let mut futures = vec::from_fn(1000, |ind| do extra::future::spawn { partial_sum(ind) });
 
     let mut final_res = 0f64;
     for ft in futures.mut_iter()  {

branches/try/src/libextra/fileinput.rs

@@ -420,6 +420,7 @@ mod test {
     use std::rt::io;
     use std::rt::io::Writer;
     use std::rt::io::file;
+    use std::uint;
     use std::vec;
 
     fn make_file(path : &Path, contents: &[~str]) {

branches/try/src/libextra/future.rs

@@ -25,16 +25,27 @@
 
 #[allow(missing_doc)];
 
+
+use std::cast;
 use std::cell::Cell;
 use std::comm::{PortOne, oneshot};
 use std::task;
 use std::util::replace;
 
-/// A type encapsulating the result of a computation which may not be complete
+#[doc = "The future type"]
 pub struct Future<A> {
     priv state: FutureState<A>,
 }
 
+// n.b. It should be possible to get rid of this.
+// Add a test, though -- tjc
+// FIXME(#2829) -- futures should not be copyable, because they close
+// over ~fn's that have pipes and so forth within!
+#[unsafe_destructor]
+impl<A> Drop for Future<A> {
+    fn drop(&mut self) {}
+}
+
 enum FutureState<A> {
     Pending(~fn() -> A),
     Evaluating,
@@ -60,171 +71,156 @@ impl<A> Future<A> {
             _ => fail!( "Logic error." ),
         }
     }
+}
 
+impl<A> Future<A> {
     pub fn get_ref<'a>(&'a mut self) -> &'a A {
         /*!
         * Executes the future's closure and then returns a borrowed
         * pointer to the result.  The borrowed pointer lasts as long as
         * the future.
         */
-        match self.state {
-            Forced(ref v) => return v,
-            Evaluating => fail!("Recursive forcing of future!"),
-            Pending(_) => {
-                match replace(&mut self.state, Evaluating) {
+        unsafe {
+            {
+                match self.state {
+                    Forced(ref mut v) => { return cast::transmute(v); }
+                    Evaluating => fail!("Recursive forcing of future!"),
+                    Pending(_) => {}
+                }
+            }
+            {
+                let state = replace(&mut self.state, Evaluating);
+                match state {
                     Forced(_) | Evaluating => fail!("Logic error."),
                     Pending(f) => {
                         self.state = Forced(f());
-                        self.get_ref()
+                        cast::transmute(self.get_ref())
                     }
                 }
             }
         }
     }
+}
 
-    pub fn from_value(val: A) -> Future<A> {
-        /*!
-         * Create a future from a value.
-         *
-         * The value is immediately available and calling `get` later will
-         * not block.
-         */
+pub fn from_value<A>(val: A) -> Future<A> {
+    /*!
+     * Create a future from a value.
+     *
+     * The value is immediately available and calling `get` later will
+     * not block.
+     */
 
-        Future {state: Forced(val)}
-    }
+    Future {state: Forced(val)}
+}
 
-    pub fn from_fn(f: ~fn() -> A) -> Future<A> {
-        /*!
-         * Create a future from a function.
-         *
-         * The first time that the value is requested it will be retrieved by
-         * calling the function.  Note that this function is a local
-         * function. It is not spawned into another task.
-         */
-
-        Future {state: Pending(f)}
+pub fn from_port<A:Send>(port: PortOne<A>) -> Future<A> {
+    /*!
+     * Create a future from a port
+     *
+     * The first time that the value is requested the task will block
+     * waiting for the result to be received on the port.
+     */
+
+    let port = Cell::new(port);
+    do from_fn {
+        port.take().recv()
     }
 }
 
-impl<A:Send> Future<A> {
-    pub fn from_port(port: PortOne<A>) -> Future<A> {
-        /*!
-         * Create a future from a port
-         *
-         * The first time that the value is requested the task will block
-         * waiting for the result to be received on the port.
-         */
-
-        let port = Cell::new(port);
-        do Future::from_fn {
-            port.take().recv()
-        }
-    }
+pub fn from_fn<A>(f: ~fn() -> A) -> Future<A> {
+    /*!
+     * Create a future from a function.
+     *
+     * The first time that the value is requested it will be retrieved by
+     * calling the function.  Note that this function is a local
+     * function. It is not spawned into another task.
+     */
 
-    pub fn spawn(blk: ~fn() -> A) -> Future<A> {
-        /*!
-         * Create a future from a unique closure.
-         *
-         * The closure will be run in a new task and its result used as the
-         * value of the future.
-         */
+    Future {state: Pending(f)}
+}
 
-        let (port, chan) = oneshot();
+pub fn spawn<A:Send>(blk: ~fn() -> A) -> Future<A> {
+    /*!
+     * Create a future from a unique closure.
+     *
+     * The closure will be run in a new task and its result used as the
+     * value of the future.
+     */
 
-        do task::spawn_with(chan) |chan| {
-            chan.send(blk());
-        }
+    let (port, chan) = oneshot();
 
-        Future::from_port(port)
+    let chan = Cell::new(chan);
+    do task::spawn {
+        let chan = chan.take();
+        chan.send(blk());
     }
 
-    pub fn spawn_with<B: Send>(v: B, blk: ~fn(B) -> A) -> Future<A> {
-        /*!
-         * Create a future from a unique closure taking one argument.
-         *
-         * The closure and its argument will be moved into a new task. The
-         * closure will be run and its result used as the value of the future.
-         */
-
-         let (port, chan) = oneshot();
-
-         do task::spawn_with((v, chan)) |(v, chan)| {
-            chan.send(blk(v));
-         }
-
-         Future::from_port(port)
-    }
+    return from_port(port);
 }
 
 #[cfg(test)]
 mod test {
-    use future::Future;
+    use future::*;
 
     use std::cell::Cell;
     use std::comm::oneshot;
     use std::task;
 
     #[test]
     fn test_from_value() {
-        let mut f = Future::from_value(~"snail");
+        let mut f = from_value(~"snail");
         assert_eq!(f.get(), ~"snail");
     }
 
     #[test]
     fn test_from_port() {
         let (po, ch) = oneshot();
         ch.send(~"whale");
-        let mut f = Future::from_port(po);
+        let mut f = from_port(po);
         assert_eq!(f.get(), ~"whale");
     }
 
     #[test]
     fn test_from_fn() {
-        let mut f = Future::from_fn(|| ~"brail");
+        let mut f = from_fn(|| ~"brail");
         assert_eq!(f.get(), ~"brail");
     }
 
     #[test]
     fn test_interface_get() {
-        let mut f = Future::from_value(~"fail");
+        let mut f = from_value(~"fail");
         assert_eq!(f.get(), ~"fail");
     }
 
     #[test]
     fn test_interface_unwrap() {
-        let f = Future::from_value(~"fail");
+        let f = from_value(~"fail");
         assert_eq!(f.unwrap(), ~"fail");
     }
 
     #[test]
     fn test_get_ref_method() {
-        let mut f = Future::from_value(22);
+        let mut f = from_value(22);
         assert_eq!(*f.get_ref(), 22);
     }
 
     #[test]
     fn test_spawn() {
-        let mut f = Future::spawn(|| ~"bale");
+        let mut f = spawn(|| ~"bale");
         assert_eq!(f.get(), ~"bale");
     }
 
-    #[test]
-    fn test_spawn_with() {
-        let mut f = Future::spawn_with(~"gale", |s| { s });
-        assert_eq!(f.get(), ~"gale");
-    }
-
     #[test]
     #[should_fail]
     fn test_futurefail() {
-        let mut f = Future::spawn(|| fail!());
+        let mut f = spawn(|| fail!());
         let _x: ~str = f.get();
     }
 
     #[test]
     fn test_sendable_future() {
         let expected = "schlorf";
-        let f = Cell::new(do Future::spawn { expected });
+        let f = Cell::new(do spawn { expected });
         do task::spawn {
             let mut f = f.take();
             let actual = f.get();

branches/try/src/libextra/glob.rs

@@ -512,8 +512,10 @@ impl MatchOptions {
 
 #[cfg(test)]
 mod test {
-    use std::os;
+    use std::{io, os, unstable};
+    use std::unstable::finally::Finally;
     use super::*;
+    use tempfile;
 
     #[test]
     fn test_absolute_pattern() {

branches/try/src/libextra/par.rs

@@ -14,7 +14,7 @@ use std::num;
 use std::ptr;
 use std::sys;
 use std::vec;
-use future::Future;
+use future_spawn = future::spawn;
 
 /**
  * The maximum number of tasks this module will spawn for a single
@@ -55,7 +55,7 @@ fn map_slices<A:Clone + Send,B:Clone + Send>(
             do xs.as_imm_buf |p, _len| {
                 let f = f();
                 let base = base;
-                let f = do Future::spawn() || {
+                let f = do future_spawn() || {
                     unsafe {
                         let len = end - base;
                         let slice = (ptr::offset(p, base as int),

branches/try/src/librustdoc/markdown_writer.rs

@@ -20,7 +20,7 @@ use std::result;
 use std::run;
 use std::str;
 use std::task;
-use extra::future::Future;
+use extra::future;
 
 #[deriving(Clone)]
 pub enum WriteInstr {
@@ -207,10 +207,10 @@ pub fn future_writer_factory(
     (writer_factory, markdown_po)
 }
 
-fn future_writer() -> (Writer, Future<~str>) {
+fn future_writer() -> (Writer, future::Future<~str>) {
     let (port, chan) = comm::stream();
     let writer: ~fn(instr: WriteInstr) = |instr| chan.send(instr.clone());
-    let future = do Future::from_fn || {
+    let future = do future::from_fn || {
         let mut res = ~"";
         loop {
             match port.recv() {