2012-08-13 21:06:57 -05:00
|
|
|
// NB: transitionary, de-mode-ing.
|
2012-10-03 16:52:09 -05:00
|
|
|
// tjc: allowing deprecated modes due to function issue.
|
|
|
|
// can re-forbid them after snapshot
|
2012-08-13 21:06:57 -05:00
|
|
|
#[forbid(deprecated_pattern)];
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
|
|
|
* A type representing values that may be computed concurrently and
|
|
|
|
* operations for working with them.
|
|
|
|
*
|
|
|
|
* # Example
|
|
|
|
*
|
|
|
|
* ~~~
|
|
|
|
* let delayed_fib = future::spawn {|| fib(5000) };
|
|
|
|
* make_a_sandwich();
|
2012-08-22 19:24:52 -05:00
|
|
|
* io::println(fmt!("fib(5000) = %?", delayed_fib.get()))
|
2012-07-04 16:53:12 -05:00
|
|
|
* ~~~
|
|
|
|
*/
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-04 13:12:17 -05:00
|
|
|
use either::Either;
|
2012-10-22 18:35:40 -05:00
|
|
|
use pipes::{recv, oneshot, ChanOne, PortOne, send_one, recv_one};
|
2012-09-18 19:34:08 -05:00
|
|
|
use cast::copy_lifetime;
|
2012-03-16 17:14:37 -05:00
|
|
|
|
2012-07-02 21:03:11 -05:00
|
|
|
#[doc = "The future type"]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub struct Future<A> {
|
2012-09-07 20:52:35 -05:00
|
|
|
/*priv*/ mut state: FutureState<A>,
|
2012-11-13 20:38:18 -06:00
|
|
|
}
|
2012-08-28 23:28:25 -05:00
|
|
|
|
2012-11-13 20:38:18 -06:00
|
|
|
// FIXME(#2829) -- futures should not be copyable, because they close
|
|
|
|
// over fn~'s that have pipes and so forth within!
|
|
|
|
impl<A> Future<A> : Drop {
|
|
|
|
fn finalize() {}
|
2012-08-27 18:08:17 -05:00
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-08-27 18:08:17 -05:00
|
|
|
priv enum FutureState<A> {
|
2012-08-28 08:43:58 -05:00
|
|
|
Pending(fn~() -> A),
|
2012-08-27 18:08:17 -05:00
|
|
|
Evaluating,
|
2012-09-07 15:11:03 -05:00
|
|
|
Forced(~A)
|
2012-08-27 18:08:17 -05:00
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-08-27 18:08:17 -05:00
|
|
|
/// Methods on the `future` type
|
2012-09-07 16:52:28 -05:00
|
|
|
impl<A:Copy> Future<A> {
|
2012-02-14 18:39:20 -06:00
|
|
|
fn get() -> A {
|
2012-07-04 16:53:12 -05:00
|
|
|
//! Get the value of the future
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-08-13 21:06:57 -05:00
|
|
|
get(&self)
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
2012-08-27 18:08:17 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<A> Future<A> {
|
|
|
|
fn get_ref(&self) -> &self/A {
|
|
|
|
get_ref(self)
|
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-10-13 19:07:14 -05:00
|
|
|
fn with<B>(blk: fn(&A) -> B) -> B {
|
2012-07-04 16:53:12 -05:00
|
|
|
//! Work with the value without copying it
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-08-13 21:06:57 -05:00
|
|
|
with(&self, blk)
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-02 13:37:37 -05:00
|
|
|
pub fn from_value<A>(val: A) -> Future<A> {
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
|
|
|
* Create a future from a value
|
|
|
|
*
|
|
|
|
* The value is immediately available and calling `get` later will
|
|
|
|
* not block.
|
|
|
|
*/
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-10 16:57:23 -05:00
|
|
|
Future {state: Forced(~(move val))}
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
|
|
|
|
2012-10-22 18:35:40 -05:00
|
|
|
pub fn from_port<A:Send>(port: PortOne<A>) ->
|
2012-09-26 19:20:14 -05:00
|
|
|
Future<A> {
|
2012-08-24 18:26:41 -05:00
|
|
|
/*!
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-07-02 21:03:11 -05:00
|
|
|
|
2012-09-10 16:57:23 -05:00
|
|
|
let port = ~mut Some(move port);
|
2012-07-02 21:03:11 -05:00
|
|
|
do from_fn |move port| {
|
2012-08-20 14:23:37 -05:00
|
|
|
let mut port_ = None;
|
2012-07-02 21:03:11 -05:00
|
|
|
port_ <-> *port;
|
2012-09-11 19:17:54 -05:00
|
|
|
let port = option::unwrap(move port_);
|
2012-09-10 16:57:23 -05:00
|
|
|
match recv(move port) {
|
2012-10-22 18:35:40 -05:00
|
|
|
oneshot::send(move data) => move data
|
2012-07-02 21:03:11 -05:00
|
|
|
}
|
2012-02-18 17:23:56 -06:00
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
|
|
|
|
2012-10-04 21:58:31 -05:00
|
|
|
pub fn from_fn<A>(f: ~fn() -> A) -> Future<A> {
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
|
|
|
* Create a future from a function.
|
|
|
|
*
|
|
|
|
* The first time that the value is requested it will be retreived by
|
|
|
|
* calling the function. Note that this function is a local
|
|
|
|
* function. It is not spawned into another task.
|
|
|
|
*/
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-10 16:57:23 -05:00
|
|
|
Future {state: Pending(move f)}
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
|
|
|
|
2012-10-04 21:58:31 -05:00
|
|
|
pub fn spawn<A:Send>(blk: fn~() -> A) -> Future<A> {
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-10-22 18:35:40 -05:00
|
|
|
let (chan, port) = oneshot::init();
|
2012-10-22 18:22:47 -05:00
|
|
|
|
|
|
|
let chan = ~mut Some(move chan);
|
|
|
|
do task::spawn |move blk, move chan| {
|
|
|
|
let chan = option::swap_unwrap(&mut *chan);
|
2012-10-22 18:35:40 -05:00
|
|
|
send_one(move chan, blk());
|
2012-10-22 18:22:47 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return from_port(move port);
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
|
|
|
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn get_ref<A>(future: &r/Future<A>) -> &r/A {
|
2012-08-27 18:08:17 -05:00
|
|
|
/*!
|
|
|
|
* 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.
|
2012-09-07 15:11:03 -05:00
|
|
|
return unsafe{ copy_lifetime(future, &**v) }; // ...extend it.
|
2012-08-27 18:08:17 -05:00
|
|
|
}
|
|
|
|
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) => {
|
2012-09-07 15:11:03 -05:00
|
|
|
future.state = Forced(~f());
|
2012-08-27 18:08:17 -05:00
|
|
|
return get_ref(future);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn get<A:Copy>(future: &Future<A>) -> A {
|
2012-07-04 16:53:12 -05:00
|
|
|
//! Get the value of the future
|
2012-02-18 17:23:56 -06:00
|
|
|
|
2012-08-27 18:08:17 -05:00
|
|
|
*get_ref(future)
|
2012-02-18 17:23:56 -06:00
|
|
|
}
|
|
|
|
|
2012-10-13 19:07:14 -05:00
|
|
|
pub fn with<A,B>(future: &Future<A>, blk: fn(&A) -> B) -> B {
|
2012-07-04 16:53:12 -05:00
|
|
|
//! Work with the value without copying it
|
2012-02-18 17:23:56 -06:00
|
|
|
|
2012-08-27 18:08:17 -05:00
|
|
|
blk(get_ref(future))
|
2012-02-18 17:23:56 -06:00
|
|
|
}
|
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[allow(non_implicitly_copyable_typarams)]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub mod test {
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn test_from_value() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = from_value(~"snail");
|
|
|
|
assert get(&f) == ~"snail";
|
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn test_from_port() {
|
2012-10-22 18:35:40 -05:00
|
|
|
let (ch, po) = oneshot::init();
|
|
|
|
send_one(move ch, ~"whale");
|
2012-09-19 00:35:28 -05:00
|
|
|
let f = from_port(move po);
|
2012-09-02 18:34:20 -05:00
|
|
|
assert get(&f) == ~"whale";
|
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn test_from_fn() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = from_fn(|| ~"brail");
|
|
|
|
assert get(&f) == ~"brail";
|
|
|
|
}
|
2012-02-18 17:23:56 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn test_interface_get() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = from_value(~"fail");
|
|
|
|
assert f.get() == ~"fail";
|
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn test_with() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = from_value(~"nail");
|
|
|
|
assert with(&f, |v| copy *v) == ~"nail";
|
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn test_get_ref_method() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = from_value(22);
|
|
|
|
assert *f.get_ref() == 22;
|
|
|
|
}
|
2012-08-27 18:08:17 -05:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn test_get_ref_fn() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = from_value(22);
|
|
|
|
assert *get_ref(&f) == 22;
|
|
|
|
}
|
2012-08-27 18:08:17 -05:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn test_interface_with() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = from_value(~"kale");
|
|
|
|
assert f.with(|v| copy *v) == ~"kale";
|
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn test_spawn() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = spawn(|| ~"bale");
|
|
|
|
assert get(&f) == ~"bale";
|
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
|
|
|
#[should_fail]
|
|
|
|
#[ignore(cfg(target_os = "win32"))]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn test_futurefail() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = spawn(|| fail);
|
|
|
|
let _x: ~str = get(&f);
|
|
|
|
}
|
2012-08-28 08:43:58 -05:00
|
|
|
|
|
|
|
#[test]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub fn test_sendable_future() {
|
2012-08-28 08:43:58 -05:00
|
|
|
let expected = ~"schlorf";
|
2012-09-10 18:37:20 -05:00
|
|
|
let f = do spawn |copy expected| { copy expected };
|
2012-09-19 00:35:28 -05:00
|
|
|
do task::spawn |move f, move expected| {
|
2012-08-28 08:43:58 -05:00
|
|
|
let actual = get(&f);
|
|
|
|
assert actual == expected;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|