---

yaml
---
r: 65067
b: refs/heads/master
c: 9b6b0e1
h: refs/heads/master
i:
  65065: 716dee8
  65063: ccac5b4
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 3ee479f3e98474cd8125432f7a0c5c18bc2bd342
+refs/heads/master: 9b6b0e1e646b42de7205a21bf73e5c4c2b203a6b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/doc/tutorial-tasks.md

@@ -43,24 +43,22 @@ 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,
-* [`std::future`] - A type representing values that may be computed concurrently and retrieved at a later time.
+  for safely sharing immutable data
 
 [`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
 
@@ -72,7 +70,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!"); }
@@ -147,8 +145,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();
 
@@ -235,7 +233,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);
@@ -284,51 +282,6 @@ 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
@@ -410,8 +363,8 @@ either task fails, it kills the other one.
 ~~~
 # fn sleep_forever() { loop { task::yield() } }
 # do task::try {
-do spawn {
-    do spawn {
+do task::spawn {
+    do task::spawn {
         fail!();  // All three tasks will fail.
     }
     sleep_forever();  // Will get woken up by force, then fail

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
         }
     }
 }