rust/src/libcore/future.rs

195 lines
3.8 KiB
Rust
Raw Normal View History

2012-08-13 21:06:57 -05:00
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
#[forbid(deprecated_pattern)];
/*!
* 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-08-14 18:54:13 -05:00
import either::Either;
import pipes::recv;
2012-08-15 16:10:46 -05:00
export Future;
export extensions;
export from_value;
export from_port;
export from_fn;
export get;
export with;
export spawn;
// for task.rs
export future_pipe;
#[doc = "The future type"]
2012-08-15 16:10:46 -05:00
enum Future<A> = {
2012-08-14 18:54:13 -05:00
mut v: Either<@A, fn@() -> A>
};
/// Methods on the `future` type
2012-08-15 16:10:46 -05:00
impl<A:copy send> Future<A> {
fn get() -> A {
//! Get the value of the future
2012-08-13 21:06:57 -05:00
get(&self)
}
2012-08-13 21:06:57 -05:00
fn with<B>(blk: fn((&A)) -> B) -> B {
//! Work with the value without copying it
2012-08-13 21:06:57 -05:00
with(&self, blk)
}
}
2012-08-15 16:10:46 -05:00
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.
*/
2012-08-15 16:10:46 -05:00
Future({
2012-08-14 18:54:13 -05:00
mut v: either::Left(@val)
})
}
2012-08-22 19:24:52 -05:00
macro_rules! move_it (
{$x:expr} => { unsafe { let y <- *ptr::addr_of($x); y } }
2012-08-22 19:24:52 -05:00
)
2012-08-15 16:10:46 -05:00
fn from_port<A:send>(+port: future_pipe::client::waiting<A>) -> Future<A> {
#[doc = "
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 = ~mut some(port);
do from_fn |move port| {
let mut port_ = none;
port_ <-> *port;
let port = option::unwrap(port_);
2012-08-06 14:34:08 -05:00
match recv(port) {
2012-08-22 19:24:52 -05:00
future_pipe::completed(data) => move_it!(data)
}
}
}
2012-08-15 16:10:46 -05:00
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 retreived by
* calling the function. Note that this function is a local
* function. It is not spawned into another task.
*/
2012-08-15 16:10:46 -05:00
Future({
2012-08-14 18:54:13 -05:00
mut v: either::Right(f)
})
}
2012-08-15 16:10:46 -05:00
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.
*/
from_port(pipes::spawn_service_recv(future_pipe::init, |ch| {
future_pipe::server::completed(ch, blk());
}))
}
2012-08-15 16:10:46 -05:00
fn get<A:copy>(future: &Future<A>) -> A {
//! Get the value of the future
2012-08-13 21:06:57 -05:00
do with(future) |v| { *v }
}
2012-08-15 16:10:46 -05:00
fn with<A,B>(future: &Future<A>, blk: fn((&A)) -> B) -> B {
//! Work with the value without copying it
2012-08-06 14:34:08 -05:00
let v = match copy future.v {
2012-08-14 18:54:13 -05:00
either::Left(v) => v,
either::Right(f) => {
let v = @f();
2012-08-14 18:54:13 -05:00
future.v = either::Left(v);
v
}
};
2012-08-13 21:06:57 -05:00
blk(v)
}
2012-07-06 01:14:27 -05:00
proto! future_pipe {
waiting:recv<T:send> {
completed(T) -> !
2012-07-06 01:14:27 -05:00
}
}
#[test]
fn test_from_value() {
let f = from_value(~"snail");
2012-08-13 21:06:57 -05:00
assert get(&f) == ~"snail";
}
#[test]
fn test_from_port() {
let (po, ch) = future_pipe::init();
future_pipe::server::completed(ch, ~"whale");
let f = from_port(po);
2012-08-13 21:06:57 -05:00
assert get(&f) == ~"whale";
}
#[test]
fn test_from_fn() {
let f = fn@() -> ~str { ~"brail" };
let f = from_fn(f);
2012-08-13 21:06:57 -05:00
assert get(&f) == ~"brail";
}
#[test]
fn test_interface_get() {
let f = from_value(~"fail");
assert f.get() == ~"fail";
}
#[test]
fn test_with() {
let f = from_value(~"nail");
2012-08-13 21:06:57 -05:00
assert with(&f, |v| *v) == ~"nail";
}
#[test]
fn test_interface_with() {
let f = from_value(~"kale");
2012-08-13 21:06:57 -05:00
assert f.with(|v| *v) == ~"kale";
}
#[test]
fn test_spawn() {
let f = spawn(|| ~"bale");
2012-08-13 21:06:57 -05:00
assert get(&f) == ~"bale";
}
#[test]
#[should_fail]
#[ignore(cfg(target_os = "win32"))]
fn test_futurefail() {
2012-06-30 18:19:07 -05:00
let f = spawn(|| fail);
2012-08-13 21:06:57 -05:00
let _x: ~str = get(&f);
}