---

yaml
---
r: 65052
b: refs/heads/master
c: 4b13895
h: refs/heads/master
v: v3

Author: Olivier Saut

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5242464d543f0a7e811bcfd7fe8943b62842148a
+refs/heads/master: 4b13895c2f43024b2b0986d4c2ddcb742926c3c6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/doc/tutorial-tasks.md

@@ -43,22 +43,24 @@ in the core and standard libraries, which are still under development
 and do not always present a consistent or complete interface.
 
 For your reference, these are the standard modules involved in Rust
-concurrency at this writing.
+concurrency at this writing:
 
-* [`core::task`] - All code relating to tasks and task scheduling
-* [`core::comm`] - The message passing interface
-* [`core::pipes`] - The underlying messaging infrastructure
-* [`std::comm`] - Additional messaging types based on `core::pipes`
-* [`std::sync`] - More exotic synchronization tools, including locks
+* [`core::task`] - All code relating to tasks and task scheduling,
+* [`core::comm`] - The message passing interface,
+* [`core::pipes`] - The underlying messaging infrastructure,
+* [`std::comm`] - Additional messaging types based on `core::pipes`,
+* [`std::sync`] - More exotic synchronization tools, including locks,
 * [`std::arc`] - The ARC (atomically reference counted) type,
-  for safely sharing immutable data
+  for safely sharing immutable data,
+* [`std::future`] - A type representing values that may be computed concurrently and retrieved at a later time.
 
 [`core::task`]: core/task.html
 [`core::comm`]: core/comm.html
 [`core::pipes`]: core/pipes.html
 [`std::comm`]: std/comm.html
 [`std::sync`]: std/sync.html
 [`std::arc`]: std/arc.html
+[`std::future`]: std/future.html
 
 # Basics
 
@@ -70,7 +72,7 @@ closure in the new task.
 
 ~~~~
 # use core::io::println;
-use core::task::spawn;
+# use core::task::spawn;
 
 // Print something profound in a different task using a named function
 fn print_message() { println("I am running in a different task!"); }
@@ -145,8 +147,8 @@ endpoint. Consider the following example of calculating two results
 concurrently:
 
 ~~~~
-use core::task::spawn;
-use core::comm::{stream, Port, Chan};
+# use core::task::spawn;
+# use core::comm::{stream, Port, Chan};
 
 let (port, chan): (Port<int>, Chan<int>) = stream();
 
@@ -233,7 +235,7 @@ Instead we can use a `SharedChan`, a type that allows a single
 
 ~~~
 # use core::task::spawn;
-use core::comm::{stream, SharedChan};
+# use core::comm::{stream, SharedChan};
 
 let (port, chan) = stream();
 let chan = SharedChan::new(chan);
@@ -282,6 +284,51 @@ let result = ports.foldl(0, |accum, port| *accum + port.recv() );
 # fn some_expensive_computation(_i: uint) -> int { 42 }
 ~~~
 
+## Futures
+With `std::future`, rust has a mechanism for requesting a computation and getting the result
+later.
+
+The basic example below illustrates this.
+~~~
+# fn make_a_sandwich() {};
+fn fib(n: uint) -> uint {
+    // lengthy computation returning an uint
+    12586269025
+}
+
+let mut delayed_fib = std::future::spawn (|| fib(50) );
+make_a_sandwich();
+println(fmt!("fib(50) = %?", delayed_fib.get()))
+~~~
+
+The call to `future::spawn` returns immediately a `future` object regardless of how long it
+takes to run `fib(50)`. You can then make yourself a sandwich while the computation of `fib` is
+running. The result of the execution of the method is obtained by calling `get` on the future.
+This call will block until the value is available (*i.e.* the computation is complete). Note that
+the future needs to be mutable so that it can save the result for next time `get` is called.
+
+Here is another example showing how futures allow you to background computations. The workload will
+be distributed on the available cores.
+~~~
+fn partial_sum(start: uint) -> f64 {
+    let mut local_sum = 0f64;
+    for uint::range(start*100000, (start+1)*100000) |num| {
+        local_sum += (num as f64 + 1.0).pow(-2.0);
+    }
+    local_sum
+}
+
+fn main() {
+    let mut futures = vec::from_fn(1000, |ind| do std::future::spawn { partial_sum(ind) });
+
+    let mut final_res = 0f64;
+    for futures.each_mut |ft|  {
+        final_res += ft.get();
+    }
+    println(fmt!("π^2/6 is not far from : %?", final_res));
+}
+~~~
+
 # Handling task failure
 
 Rust has a built-in mechanism for raising exceptions. The `fail!()` macro
@@ -363,8 +410,8 @@ either task fails, it kills the other one.
 ~~~
 # fn sleep_forever() { loop { task::yield() } }
 # do task::try {
-do task::spawn {
-    do task::spawn {
+do spawn {
+    do spawn {
         fail!();  // All three tasks will fail.
     }
     sleep_forever();  // Will get woken up by force, then fail

trunk/mk/platform.mk

@@ -239,32 +239,6 @@ CFG_RUN_arm-linux-androideabi=
 CFG_RUN_TARG_arm-linux-androideabi=
 RUSTC_FLAGS_arm-linux-androideabi :=--android-cross-path=$(CFG_ANDROID_CROSS_PATH)
 
-# arm-unknown-linux-gnueabihf configuration
-CC_arm-unknown-linux-gnueabihf=arm-linux-gnueabihf-gcc
-CXX_arm-unknown-linux-gnueabihf=arm-linux-gnueabihf-g++
-CPP_arm-unknown-linux-gnueabihf=arm-linux-gnueabihf-gcc -E
-AR_arm-unknown-linux-gnueabihf=arm-linux-gnueabihf-ar
-CFG_LIB_NAME_arm-unknown-linux-gnueabihf=lib$(1).so
-CFG_LIB_GLOB_arm-unknown-linux-gnueabihf=lib$(1)-*.so
-CFG_LIB_DSYM_GLOB_arm-unknown-linux-gnueabihf=lib$(1)-*.dylib.dSYM
-CFG_GCCISH_CFLAGS_arm-unknown-linux-gnueabihf := -Wall -g -fPIC
-CFG_GCCISH_CXXFLAGS_arm-unknown-linux-gnueabihf := -fno-rtti
-CFG_GCCISH_LINK_FLAGS_arm-unknown-linux-gnueabihf := -shared -fPIC -g
-CFG_GCCISH_DEF_FLAG_arm-unknown-linux-gnueabihf := -Wl,--export-dynamic,--dynamic-list=
-CFG_GCCISH_PRE_LIB_FLAGS_arm-unknown-linux-gnueabihf := -Wl,-whole-archive
-CFG_GCCISH_POST_LIB_FLAGS_arm-unknown-linux-gnueabihf := -Wl,-no-whole-archive
-CFG_DEF_SUFFIX_arm-unknown-linux-gnueabihf := .linux.def
-CFG_INSTALL_NAME_ar,-unknown-linux-gnueabihf =
-CFG_LIBUV_LINK_FLAGS_arm-unknown-linux-gnueabihf =
-CFG_EXE_SUFFIX_arm-unknown-linux-gnueabihf :=
-CFG_WINDOWSY_arm-unknown-linux-gnueabihf :=
-CFG_UNIXY_arm-unknown-linux-gnueabihf := 1
-CFG_PATH_MUNGE_arm-unknown-linux-gnueabihf := true
-CFG_LDPATH_arm-unknown-linux-gnueabihf :=
-CFG_RUN_arm-unknown-linux-gnueabihf=
-CFG_RUN_TARG_arm-unknown-linux-gnueabihf=
-RUSTC_FLAGS_arm-unknown-linux-gnueabihf := --linker=$(CC_arm-unknown-linux-gnueabihf)
-
 # mips-unknown-linux-gnu configuration
 CC_mips-unknown-linux-gnu=mips-linux-gnu-gcc
 CXX_mips-unknown-linux-gnu=mips-linux-gnu-g++

trunk/mk/rt.mk

@@ -26,11 +26,7 @@
 # Hack for passing flags into LIBUV, see below.
 LIBUV_FLAGS_i386 = -m32 -fPIC
 LIBUV_FLAGS_x86_64 = -m64 -fPIC
-ifeq ($(OSTYPE_$(1)), linux-androideabi)
 LIBUV_FLAGS_arm = -fPIC -DANDROID -std=gnu99
-else
-LIBUV_FLAGS_arm = -fPIC -std=gnu99
-endif
 LIBUV_FLAGS_mips = -fPIC -mips32r2 -msoft-float -mabi=32
 
 # when we're doing a snapshot build, we intentionally degrade as many

trunk/src/libcore/bool.rs

@@ -49,10 +49,12 @@ pub fn is_false(v: bool) -> bool { !v }
 /// Parse logic value from `s`
 impl FromStr for bool {
     fn from_str(s: &str) -> Option<bool> {
-        match s {
-            "true"  => Some(true),
-            "false" => Some(false),
-            _       => None,
+        if s == "true" {
+            Some(true)
+        } else if s == "false" {
+            Some(false)
+        } else {
+            None
         }
     }
 }

trunk/src/libcore/cmp.rs

@@ -127,11 +127,12 @@ totalord_impl!(uint)
 
 totalord_impl!(char)
 
-/// Compares (a1, b1) against (a2, b2), where the a values are more significant.
 pub fn cmp2<A:TotalOrd,B:TotalOrd>(
     a1: &A, b1: &B,
     a2: &A, b2: &B) -> Ordering
 {
+    //! Compares (a1, b1) against (a2, b2), where the a values are more significant.
+
     match a1.cmp(a2) {
         Less => Less,
         Greater => Greater,

trunk/src/libcore/either.rs

@@ -26,22 +26,26 @@ pub enum Either<T, U> {
     Right(U)
 }
 
-/// Applies a function based on the given either value
-///
-/// If `value` is left(T) then `f_left` is applied to its contents, if
-/// `value` is right(U) then `f_right` is applied to its contents, and the
-/// result is returned.
 #[inline(always)]
 pub fn either<T, U, V>(f_left: &fn(&T) -> V,
                        f_right: &fn(&U) -> V, value: &Either<T, U>) -> V {
+    /*!
+     * Applies a function based on the given either value
+     *
+     * If `value` is left(T) then `f_left` is applied to its contents, if
+     * `value` is right(U) then `f_right` is applied to its contents, and the
+     * result is returned.
+     */
+
     match *value {
-        Left(ref l) => f_left(l),
-        Right(ref r) => f_right(r)
+      Left(ref l) => f_left(l),
+      Right(ref r) => f_right(r)
     }
 }
 
-/// Extracts from a vector of either all the left values
 pub fn lefts<T:Copy,U>(eithers: &[Either<T, U>]) -> ~[T] {
+    //! Extracts from a vector of either all the left values
+
     do vec::build_sized(eithers.len()) |push| {
         for eithers.each |elt| {
             match *elt {
@@ -52,8 +56,9 @@ pub fn lefts<T:Copy,U>(eithers: &[Either<T, U>]) -> ~[T] {
     }
 }
 
-/// Extracts from a vector of either all the right values
 pub fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
+    //! Extracts from a vector of either all the right values
+
     do vec::build_sized(eithers.len()) |push| {
         for eithers.each |elt| {
             match *elt {
@@ -64,73 +69,80 @@ pub fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
     }
 }
 
-/// Extracts from a vector of either all the left values and right values
-///
-/// Returns a structure containing a vector of left values and a vector of
-/// right values.
-pub fn partition<T, U>(eithers: ~[Either<T, U>]) -> (~[T], ~[U]) {
+pub fn partition<T, U>(eithers: ~[Either<T, U>])
+    -> (~[T], ~[U]) {
+    /*!
+     * Extracts from a vector of either all the left values and right values
+     *
+     * Returns a structure containing a vector of left values and a vector of
+     * right values.
+     */
+
     let mut lefts: ~[T] = ~[];
     let mut rights: ~[U] = ~[];
     do vec::consume(eithers) |_i, elt| {
         match elt {
-            Left(l) => lefts.push(l),
-            Right(r) => rights.push(r)
+          Left(l) => lefts.push(l),
+          Right(r) => rights.push(r)
         }
     }
     return (lefts, rights);
 }
 
-/// Flips between left and right of a given either
 #[inline(always)]
 pub fn flip<T, U>(eith: Either<T, U>) -> Either<U, T> {
+    //! Flips between left and right of a given either
+
     match eith {
-        Right(r) => Left(r),
-        Left(l) => Right(l)
+      Right(r) => Left(r),
+      Left(l) => Right(l)
     }
 }
 
-/// Converts either::t to a result::t
-///
-/// Converts an `either` type to a `result` type, making the "right" choice
-/// an ok result, and the "left" choice a fail
 #[inline(always)]
-pub fn to_result<T, U>(eith: Either<T, U>) -> Result<U, T> {
+pub fn to_result<T, U>(eith: Either<T, U>)
+    -> Result<U, T> {
+    /*!
+     * Converts either::t to a result::t
+     *
+     * Converts an `either` type to a `result` type, making the "right" choice
+     * an ok result, and the "left" choice a fail
+     */
+
     match eith {
-        Right(r) => result::Ok(r),
-        Left(l) => result::Err(l)
+      Right(r) => result::Ok(r),
+      Left(l) => result::Err(l)
     }
 }
 
-/// Checks whether the given value is a left
 #[inline(always)]
 pub fn is_left<T, U>(eith: &Either<T, U>) -> bool {
-    match *eith {
-        Left(_) => true,
-        _ => false
-    }
+    //! Checks whether the given value is a left
+
+    match *eith { Left(_) => true, _ => false }
 }
 
-/// Checks whether the given value is a right
 #[inline(always)]
 pub fn is_right<T, U>(eith: &Either<T, U>) -> bool {
-    match *eith {
-        Right(_) => true,
-        _ => false
-    }
+    //! Checks whether the given value is a right
+
+    match *eith { Right(_) => true, _ => false }
 }
 
-/// Retrieves the value in the left branch. Fails if the either is Right.
 #[inline(always)]
 pub fn unwrap_left<T,U>(eith: Either<T,U>) -> T {
+    //! Retrieves the value in the left branch. Fails if the either is Right.
+
     match eith {
         Left(x) => x,
         Right(_) => fail!("either::unwrap_left Right")
     }
 }
 
-/// Retrieves the value in the right branch. Fails if the either is Left.
 #[inline(always)]
 pub fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
+    //! Retrieves the value in the right branch. Fails if the either is Left.
+
     match eith {
         Right(x) => x,
         Left(_) => fail!("either::unwrap_right Left")