rust/src/libstd/future.rs

207 lines
4.8 KiB
Rust
Raw Normal View History

// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
/*!
* 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()))
* ~~~
*/
use core::cast;
use core::cell::Cell;
2013-05-03 17:57:18 -05:00
use core::comm::{PortOne, oneshot, send_one};
2013-02-02 05:10:12 -06:00
use core::pipes::recv;
use core::task;
#[doc = "The future type"]
pub struct Future<A> {
priv mut state: FutureState<A>,
2012-11-13 20:38:18 -06: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!
#[unsafe_destructor]
impl<A> Drop for Future<A> {
fn finalize(&self) {}
}
priv enum FutureState<A> {
Pending(~fn() -> A),
Evaluating,
Forced(A)
}
/// Methods on the `future` type
pub impl<A:Copy> Future<A> {
2013-03-07 20:11:09 -06:00
fn get(&self) -> A {
//! Get the value of the future
*(self.get_ref())
}
}
pub impl<A> Future<A> {
fn get_ref<'a>(&'a 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.
*/
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;
2013-02-15 01:30:30 -06:00
match state {
Forced(_) | Evaluating => fail!(~"Logic error."),
2013-02-15 01:30:30 -06:00
Pending(f) => {
self.state = Forced(f());
self.get_ref()
}
}
}
}
}
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.
*/
2013-02-15 01:30:30 -06:00
Future {state: Forced(val)}
}
pub fn from_port<A:Owned>(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(port);
2013-02-15 01:30:30 -06:00
do from_fn || {
let port = port.take().unwrap();
2013-02-15 01:30:30 -06:00
match recv(port) {
oneshot::send(data) => data
}
}
}
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 retreived by
* calling the function. Note that this function is a local
* function. It is not spawned into another task.
*/
2013-02-15 01:30:30 -06:00
Future {state: Pending(f)}
}
pub fn spawn<A:Owned>(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.
*/
let (port, chan) = oneshot();
let chan = Cell(chan);
do task::spawn {
let chan = chan.take();
2013-02-15 01:30:30 -06:00
send_one(chan, blk());
}
2013-02-15 01:30:30 -06:00
return from_port(port);
}
#[allow(non_implicitly_copyable_typarams)]
2013-02-26 23:10:03 -06:00
#[cfg(test)]
mod test {
use future::*;
use core::comm::{oneshot, send_one};
2012-12-28 14:46:08 -06:00
use core::task;
#[test]
fn test_from_value() {
let f = from_value(~"snail");
2013-03-28 20:39:09 -05:00
assert!(f.get() == ~"snail");
}
#[test]
fn test_from_port() {
2013-04-28 00:05:39 -05:00
let (po, ch) = oneshot();
2013-02-15 01:30:30 -06:00
send_one(ch, ~"whale");
let f = from_port(po);
2013-03-28 20:39:09 -05:00
assert!(f.get() == ~"whale");
}
#[test]
fn test_from_fn() {
let f = from_fn(|| ~"brail");
2013-03-28 20:39:09 -05:00
assert!(f.get() == ~"brail");
}
#[test]
fn test_interface_get() {
let f = from_value(~"fail");
2013-03-28 20:39:09 -05:00
assert!(f.get() == ~"fail");
}
#[test]
fn test_get_ref_method() {
let f = from_value(22);
2013-03-28 20:39:09 -05:00
assert!(*f.get_ref() == 22);
}
#[test]
fn test_spawn() {
let f = spawn(|| ~"bale");
2013-03-28 20:39:09 -05:00
assert!(f.get() == ~"bale");
}
#[test]
#[should_fail]
#[ignore(cfg(target_os = "win32"))]
fn test_futurefail() {
let f = spawn(|| fail!());
let _x: ~str = f.get();
}
#[test]
fn test_sendable_future() {
let expected = ~"schlorf";
2013-02-16 16:54:34 -06:00
let f = do spawn { copy expected };
2013-02-15 02:18:22 -06:00
do task::spawn || {
let actual = f.get();
2013-03-28 20:39:09 -05:00
assert!(actual == expected);
}
}
}