---

yaml
---
r: 148925
b: refs/heads/try2
c: da45340
h: refs/heads/master
i:
  148923: 4cbb4d5
v: v3

Author: huonw

[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: d8c4e78603eb1f658516dde08868abbe6c06bd35
+refs/heads/try2: da45340ab84603cf6932b012b977bc2e7b8d6764
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/crates.mk

@@ -49,27 +49,25 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := std extra green rustuv native flate arena glob term semver uuid serialize sync
+TARGET_CRATES := std extra green rustuv native flate arena glob term semver uuid
 HOST_CRATES := syntax rustc rustdoc
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
 DEPS_std := native:rustrt
-DEPS_extra := std serialize sync term
+DEPS_extra := std term
 DEPS_green := std
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
-DEPS_syntax := std extra term serialize
-DEPS_rustc := syntax native:rustllvm flate arena serialize sync
-DEPS_rustdoc := rustc native:sundown serialize sync
+DEPS_syntax := std extra term
+DEPS_rustc := syntax native:rustllvm flate arena
+DEPS_rustdoc := rustc native:sundown
 DEPS_flate := std native:miniz
 DEPS_arena := std extra
 DEPS_glob := std
-DEPS_serialize := std
 DEPS_term := std
 DEPS_semver := std
-DEPS_uuid := std serialize
-DEPS_sync := std
+DEPS_uuid := std extra
 
 TOOL_DEPS_compiletest := extra green rustuv
 TOOL_DEPS_rustdoc := rustdoc green rustuv

branches/try2/src/doc/guide-tasks.md

@@ -39,51 +39,26 @@ data through the global _exchange heap_.
 
 While Rust's type system provides the building blocks needed for safe
 and efficient tasks, all of the task functionality itself is implemented
-in the standard and sync libraries, which are still under development
+in the standard and extra 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:
 
 * [`std::task`] - All code relating to tasks and task scheduling,
 * [`std::comm`] - The message passing interface,
-* [`sync::DuplexStream`] - An extension of `pipes::stream` that allows both sending and receiving,
-* [`sync::SyncChan`] - An extension of `pipes::stream` that provides synchronous message sending,
-* [`sync::SyncPort`] - An extension of `pipes::stream` that acknowledges each message received,
-* [`sync::rendezvous`] - Creates a stream whose channel, upon sending a message, blocks until the 
-    message is received.
-* [`sync::Arc`] - The Arc (atomically reference counted) type, for safely sharing immutable data,
-* [`sync::RWArc`] - A dual-mode Arc protected by a reader-writer lock,
-* [`sync::MutexArc`] - An Arc with mutable data protected by a blocking mutex,
-* [`sync::Semaphore`] - A counting, blocking, bounded-waiting semaphore,
-* [`sync::Mutex`] - A blocking, bounded-waiting, mutual exclusion lock with an associated 
-    FIFO condition variable,
-* [`sync::RWLock`] - A blocking, no-starvation, reader-writer lock with an associated condvar,
-* [`sync::Barrier`] - A barrier enables multiple tasks to synchronize the beginning
-    of some computation,
-* [`sync::TaskPool`] - A task pool abstraction,
-* [`sync::Future`] - A type encapsulating the result of a computation which may not be complete,
-* [`sync::one`] - A "once initialization" primitive
-* [`sync::mutex`] - A proper mutex implementation regardless of the "flavor of task" which is
-    acquiring the lock.
+* [`extra::comm`] - Additional messaging types based on `std::comm`,
+* [`extra::sync`] - More exotic synchronization tools, including locks,
+* [`extra::arc`] - The Arc (atomically reference counted) type,
+  for safely sharing immutable data,
+* [`extra::future`] - A type representing values that may be computed concurrently and retrieved at a later time.
 
 [`std::task`]: std/task/index.html
 [`std::comm`]: std/comm/index.html
-[`sync::DuplexStream`]: sync/struct.DuplexStream.html
-[`sync::SyncChan`]: sync/struct.SyncChan.html
-[`sync::SyncPort`]: sync/struct.SyncPort.html
-[`sync::rendezvous`]: sync/fn.rendezvous.html
-[`sync::Arc`]: sync/struct.Arc.html
-[`sync::RWArc`]: sync/struct.RWArc.html
-[`sync::MutexArc`]: sync/struct.MutexArc.html
-[`sync::Semaphore`]: sync/struct.Semaphore.html
-[`sync::Mutex`]: sync/struct.Mutex.html
-[`sync::RWLock`]: sync/struct.RWLock.html
-[`sync::Barrier`]: sync/struct.Barrier.html
-[`sync::TaskPool`]: sync/struct.TaskPool.html
-[`sync::Future`]: sync/struct.Future.html
-[`sync::one`]: sync/one/index.html
-[`sync::mutex`]: sync/mutex/index.html
+[`extra::comm`]: extra/comm/index.html
+[`extra::sync`]: extra/sync/index.html
+[`extra::arc`]: extra/arc/index.html
+[`extra::future`]: extra/future/index.html
 
 # Basics
 
@@ -279,25 +254,21 @@ let result = ports.iter().fold(0, |accum, port| accum + port.recv() );
 ~~~
 
 ## Backgrounding computations: Futures
-With `sync::Future`, rust has a mechanism for requesting a computation and getting the result
+With `extra::future`, rust has a mechanism for requesting a computation and getting the result
 later.
 
 The basic example below illustrates this.
 
 ~~~
-# extern mod sync;
-
-# fn main() {
 # fn make_a_sandwich() {};
 fn fib(n: u64) -> u64 {
     // lengthy computation returning an uint
     12586269025
 }
 
-let mut delayed_fib = sync::Future::spawn(proc() fib(50));
+let mut delayed_fib = extra::future::Future::spawn(proc() fib(50));
 make_a_sandwich();
 println!("fib(50) = {:?}", delayed_fib.get())
-# }
 ~~~
 
 The call to `future::spawn` returns immediately a `future` object regardless of how long it
@@ -310,7 +281,6 @@ Here is another example showing how futures allow you to background computations
 be distributed on the available cores.
 
 ~~~
-# extern mod sync;
 # use std::vec;
 fn partial_sum(start: uint) -> f64 {
     let mut local_sum = 0f64;
@@ -321,7 +291,7 @@ fn partial_sum(start: uint) -> f64 {
 }
 
 fn main() {
-    let mut futures = vec::from_fn(1000, |ind| sync::Future::spawn( proc() { partial_sum(ind) }));
+    let mut futures = vec::from_fn(1000, |ind| extra::future::Future::spawn( proc() { partial_sum(ind) }));
 
     let mut final_res = 0f64;
     for ft in futures.mut_iter()  {
@@ -339,17 +309,16 @@ add up to a significant amount of wasted memory and would require copying the sa
 necessary.
 
 To tackle this issue, one can use an Atomically Reference Counted wrapper (`Arc`) as implemented in
-the `sync` library of Rust. With an Arc, the data will no longer be copied for each task. The Arc
+the `extra` library of Rust. With an Arc, the data will no longer be copied for each task. The Arc
 acts as a reference to the shared data and only this reference is shared and cloned.
 
 Here is a small example showing how to use Arcs. We wish to run concurrently several computations on
 a single large vector of floats. Each task needs the full vector to perform its duty.
 
 ~~~
-# extern mod sync;
 # use std::vec;
 # use std::rand;
-use sync::Arc;
+use extra::arc::Arc;
 
 fn pnorm(nums: &~[f64], p: uint) -> f64 {
     nums.iter().fold(0.0, |a,b| a+(*b).powf(&(p as f64)) ).powf(&(1.0 / (p as f64)))
@@ -379,48 +348,39 @@ at the power given as argument and takes the inverse power of this value). The A
 created by the line
 
 ~~~
-# extern mod sync;
-# use sync::Arc;
+# use extra::arc::Arc;
 # use std::vec;
 # use std::rand;
-# fn main() {
 # let numbers = vec::from_fn(1000000, |_| rand::random::<f64>());
 let numbers_arc=Arc::new(numbers);
-# }
 ~~~
 
 and a clone of it is sent to each task
 
 ~~~
-# extern mod sync;
-# use sync::Arc;
+# use extra::arc::Arc;
 # use std::vec;
 # use std::rand;
-# fn main() {
 # let numbers=vec::from_fn(1000000, |_| rand::random::<f64>());
 # let numbers_arc = Arc::new(numbers);
 # let (port, chan)  = Chan::new();
 chan.send(numbers_arc.clone());
-# }
 ~~~
 
 copying only the wrapper and not its contents.
 
 Each task recovers the underlying data by
 
 ~~~
-# extern mod sync;
-# use sync::Arc;
+# use extra::arc::Arc;
 # use std::vec;
 # use std::rand;
-# fn main() {
 # let numbers=vec::from_fn(1000000, |_| rand::random::<f64>());
 # let numbers_arc=Arc::new(numbers);
 # let (port, chan)  = Chan::new();
 # chan.send(numbers_arc.clone());
 # let local_arc : Arc<~[f64]> = port.recv();
 let task_numbers = local_arc.get();
-# }
 ~~~
 
 and can use it as if it were local.
@@ -490,27 +450,25 @@ proceed).
 
 A very common thing to do is to spawn a child task where the parent
 and child both need to exchange messages with each other. The
-function `sync::comm::DuplexStream()` supports this pattern.  We'll
+function `extra::comm::DuplexStream()` supports this pattern.  We'll
 look briefly at how to use it.
 
 To see how `DuplexStream()` works, we will create a child task
 that repeatedly receives a `uint` message, converts it to a string, and sends
 the string in response.  The child terminates when it receives `0`.
 Here is the function that implements the child task:
 
-~~~
-# extern mod sync;
-# fn main() {
-# use sync::DuplexStream;
-    fn stringifier(channel: &DuplexStream<~str, uint>) {
-        let mut value: uint;
-        loop {
-            value = channel.recv();
-            channel.send(value.to_str());
-            if value == 0 { break; }
-        }
+~~~{.ignore .linked-failure}
+# use extra::comm::DuplexStream;
+# use std::uint;
+fn stringifier(channel: &DuplexStream<~str, uint>) {
+    let mut value: uint;
+    loop {
+        value = channel.recv();
+        channel.send(uint::to_str(value));
+        if value == 0 { break; }
     }
-# }
+}
 ~~~~
 
 The implementation of `DuplexStream` supports both sending and
@@ -523,15 +481,15 @@ response itself is simply the stringified version of the received value,
 
 Here is the code for the parent task:
 
-~~~
-# extern mod sync;
+~~~{.ignore .linked-failure}
 # use std::task::spawn;
-# use sync::DuplexStream;
+# use std::uint;
+# use extra::comm::DuplexStream;
 # fn stringifier(channel: &DuplexStream<~str, uint>) {
 #     let mut value: uint;
 #     loop {
 #         value = channel.recv();
-#         channel.send(value.to_str());
+#         channel.send(uint::to_str(value));
 #         if value == 0u { break; }
 #     }
 # }

branches/try2/src/doc/index.md

@@ -41,10 +41,8 @@ li {list-style-type: none; }
 * [The `flate` compression library](flate/index.html)
 * [The `glob` file path matching library](glob/index.html)
 * [The `semver` version collation library](semver/index.html)
-* [The `serialize` value encoding/decoding library](serialize/index.html)
-* [The `sync` library for concurrency-enabled mechanisms and primitives](sync/index.html)
 * [The `term` terminal-handling library](term/index.html)
-* [The `uuid` 128-bit universally unique identifier library](uuid/index.html)
+* [The UUID library](uuid/index.html)
 
 # Tooling
 

branches/try2/src/doc/tutorial.md

@@ -509,7 +509,7 @@ fn angle(vector: (f64, f64)) -> f64 {
     let pi = f64::consts::PI;
     match vector {
       (0.0, y) if y < 0.0 => 1.5 * pi,
-      (0.0, _) => 0.5 * pi,
+      (0.0, y) => 0.5 * pi,
       (x, y) => atan(y / x)
     }
 }
@@ -519,9 +519,7 @@ A variable name in a pattern matches any value, *and* binds that name
 to the value of the matched value inside of the arm's action. Thus, `(0.0,
 y)` matches any tuple whose first element is zero, and binds `y` to
 the second element. `(x, y)` matches any two-element tuple, and binds both
-elements to variables. `(0.0,_)` matches any tuple whose first element is zero
-and does not bind anything to the second element.
-
+elements to variables.
 A subpattern can also be bound to a variable, using `variable @ pattern`. For
 example:
 

branches/try2/src/etc/check-summary.py

@@ -1,12 +1,5 @@
-# Copyright 2012-2014 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.
+#!/usr/bin/env python
+# xfail-license
 
 import glob
 import sys

branches/try2/src/etc/combine-tests.py

@@ -1,14 +1,7 @@
-# Copyright 2011-2013 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.
+#!/usr/bin/env python
+# xfail-license
 
-# This combines all the working run-pass tests into a single large crate so we
+# this combines all the working run-pass tests into a single large crate so we
 # can run it "fast": spawning zillions of windows processes is our major build
 # bottleneck (and it doesn't hurt to run faster on other platforms as well).
 

branches/try2/src/etc/copy-runtime-deps.py

@@ -1,14 +1,7 @@
-# Copyright 2013-2014 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.
+#!/usr/bin/env python
+# xfail-license
 
-# Copies Rust runtime dependencies to the specified directory.
+# Copies Rust runtime dependencies to the specified directory
 
 import snapshot, sys, os, shutil
 

branches/try2/src/etc/extract-tests.py

@@ -1,13 +1,5 @@
-# Copyright 2012-2014 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.
-
+# xfail-license
+# -*- coding: utf-8 -*-
 """
 Script for extracting compilable fragments from markdown documentation. See
 prep.js for a description of the format recognized by this tool. Expects

branches/try2/src/etc/extract_grammar.py

@@ -1,12 +1,5 @@
-# Copyright 2012-2013 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.
+#!/usr/bin/env python
+# xfail-license
 
 # This script is for extracting the grammar from the rust docs.