---

yaml
---
r: 152703
b: refs/heads/try2
c: 6750eb5
h: refs/heads/master
i:
  152701: 791ef03
  152699: f39d3d0
  152695: 3aacec5
  152687: 666649a
  152671: a57a034
  152639: 714cf90
  152575: 73925e4
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: e1038819c2ab190ace31f2f0ac7f4455e3708cfc
+refs/heads/try2: 6750eb5a05042fe3fb84708909074f33ad86d3ec
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/index.md

@@ -67,12 +67,26 @@ li {list-style-type: none; }
 
 * [The `rustdoc` manual](rustdoc.html)
 
-# External resources
+# External documentation
 
-* The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/)
+*Note: While these are great resources for learning Rust, they may
+track a particular version of Rust that is likely not exactly the same
+as that for which this documentation was generated.*
+
+* [Rust for Rubyists] - An excellent introduction for Rust; not just for Rubyists (tracks the most recent release).
+* [Rust by Example] - Short examples of common tasks in Rust (tracks the master branch).
+* [The Rust wiki](http://github.com/rust-lang/rust/wiki)
+
+[Rust for Rubyists]: http://www.rustforrubyists.com/
+[Rust by Example]: http://rustbyexample.com/
+
+# Community
+
+* [Reddit](http://reddit.com/r/rust)
+* [Stack Overflow](http://stackoverflow.com/questions/tagged/rust)
+* The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/):
     * [`#rust`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - general discussion
     * [`#rust-gamedev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev) - game development
     * [`#rust-internals`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals) - compiler and libraries
     * [`#rust-osdev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-osdev) - operating system development
-* The Rust community on [Reddit](http://reddit.com/r/rust)
-* The Rust [wiki](http://github.com/rust-lang/rust/wiki)
+

branches/try2/src/doc/rust.css

@@ -275,7 +275,7 @@ dd {
 
 nav ul {
     list-style-type: none;
-    margin: 0;
+    margin: 0 0 20px 0;
     padding-left: 0px;
 }
 

branches/try2/src/libstd/sync/task_pool.rs

@@ -8,10 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![allow(missing_doc)]
-
-/// A task pool abstraction. Useful for achieving predictable CPU
-/// parallelism.
+//! Abstraction of a task pool for basic parallelism.
 
 use core::prelude::*;
 
@@ -25,6 +22,7 @@ enum Msg<T> {
     Quit
 }
 
+/// A task pool used to execute functions in parallel.
 pub struct TaskPool<T> {
     channels: Vec<Sender<Msg<T>>>,
     next_index: uint,
@@ -40,11 +38,13 @@ impl<T> Drop for TaskPool<T> {
 }
 
 impl<T> TaskPool<T> {
-    /// Spawns a new task pool with `n_tasks` tasks. If the `sched_mode`
-    /// is None, the tasks run on this scheduler; otherwise, they run on a
-    /// new scheduler with the given mode. The provided `init_fn_factory`
-    /// returns a function which, given the index of the task, should return
-    /// local data to be kept around in that task.
+    /// Spawns a new task pool with `n_tasks` tasks. The provided
+    /// `init_fn_factory` returns a function which, given the index of the
+    /// task, should return local data to be kept around in that task.
+    ///
+    /// # Failure
+    ///
+    /// This function will fail if `n_tasks` is less than 1.
     pub fn new(n_tasks: uint,
                init_fn_factory: || -> proc(uint):Send -> T)
                -> TaskPool<T> {
@@ -87,12 +87,16 @@ impl<T> TaskPool<T> {
 
 #[test]
 fn test_task_pool() {
-    let f: || -> proc(uint):Send -> uint = || {
-        let g: proc(uint):Send -> uint = proc(i) i;
-        g
-    };
+    let f: || -> proc(uint):Send -> uint = || { proc(i) i };
     let mut pool = TaskPool::new(4, f);
     for _ in range(0, 8) {
         pool.execute(proc(i) println!("Hello from thread {}!", *i));
     }
 }
+
+#[test]
+#[should_fail]
+fn test_zero_tasks_failure() {
+    let f: || -> proc(uint):Send -> uint = || { proc(i) i };
+    TaskPool::new(0, f);
+}

branches/try2/src/libstd/task.rs

@@ -8,17 +8,33 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Utilities for managing and scheduling tasks
+//! Task creation
 //!
-//! An executing Rust program consists of a collection of lightweight tasks,
-//! each with their own stack. Tasks communicate with each other using channels
-//! (see `std::comm`) or other forms of synchronization (see `std::sync`) that
-//! ensure data-race freedom.
+//! An executing Rust program consists of a collection of tasks, each
+//! with their own stack and local state. A Rust task is typically
+//! backed by an operating system thread, making tasks 'just threads',
+//! but may also be implemented via other strategies as well
+//! (e.g. Rust comes with the [`green`](../../green/index.html)
+//! scheduling crate for creating tasks backed by green threads).
 //!
-//! Failure in one task does immediately propagate to any others (not to parent,
-//! not to child). Failure propagation is instead handled as part of task
-//! synchronization. For example, the channel `send()` and `recv()` methods will
-//! fail if the other end has hung up already.
+//! Tasks generally have their memory *isolated* from each other by
+//! virtue of Rust's owned types (which of course may only be owned by
+//! a single task at a time). Communication between tasks is primarily
+//! done through [channels](../../std/comm/index.html), Rust's
+//! message-passing types, though [other forms of task
+//! synchronization](../../std/sync/index.html) are often employed to
+//! achieve particular performance goals. In particular, types that
+//! are guaranteed to be threadsafe are easily shared between threads
+//! using the atomically-reference-counted container,
+//! [`Arc`](../../std/sync/struct.Arc.html).
+//!
+//! Fatal logic errors in Rust cause *task failure*, during which
+//! a task will unwind the stack, running destructors and freeing
+//! owned resources. Task failure is unrecoverable from within
+//! the failing task (i.e. there is no 'try/catch' in Rust), but
+//! failure may optionally be detected from a different task. If
+//! the main task fails the application will exit with a non-zero
+//! exit code.
 //!
 //! # Basic task scheduling
 //!

branches/try2/src/libsync/comm/select.rs

@@ -132,7 +132,7 @@ impl Select {
     /// event could either be that data is available or the corresponding
     /// channel has been closed.
     pub fn wait(&self) -> uint {
-        self.wait2(false)
+        self.wait2(true)
     }
 
     /// Helper method for skipping the preflight checks during testing