---

yaml
---
r: 147299
b: refs/heads/try2
c: 4a13364
h: refs/heads/master
i:
  147297: f604df7
  147295: 617aff1
v: v3

Author: sanxiyn

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

branches/try2/configure

@@ -559,27 +559,6 @@ then
         step_msg "on OS X 10.9, forcing use of clang"
         CFG_ENABLE_CLANG=1
         putvar CFG_ENABLE_CLANG
-    else 
-        # on OS X, with xcode 5 and newer, certain developers may have 
-        # cc, gcc and g++ point to a  mixture of clang and gcc
-        # if so, this will create very strange build errors 
-        # this last stanza is to detect some such problems and save the future rust
-        # contributor some time solving that issue.
-        # this detection could be generalized to other OSes aside from OS X
-        # but the issue seems most likely to happen on OS X
-
-        chk_cc () {
-            $1 --version 2> /dev/null | grep -q $2
-        }
-        # check that gcc, cc and g++ all point to the same compiler.
-        # note that for xcode 5, g++ points to clang, not clang++
-        if !((chk_cc gcc clang  && chk_cc g++ clang) ||
-            (chk_cc gcc gcc  &&( chk_cc g++ g++ || chk g++ gcc))) then
-            err "the gcc and g++ in your path point to different compilers. 
-Check which versions are in your path with  cc --version and g++ --version. 
-To resolve this problem, either fix your PATH  or run configure with --enable-clang"
-        fi
-
     fi
 fi
 

branches/try2/doc/rust.md

@@ -3329,12 +3329,6 @@ The kinds are:
     This kind includes scalars, owning pointers, owned closures, and
     structural types containing only other owned types.
     All `Send` types are `'static`.
-`Pod`
-  : Types of this kind consist of "Plain Old Data"
-    which can be copied by simply moving bits.
-    All values of this kind can be implicitly copied.
-    This kind includes scalars and immutable references,
-    as well as structural types containing other `Pod` types.
 `'static`
   : Types of this kind do not contain any borrowed pointers;
     this can be a useful guarantee for code

branches/try2/doc/tutorial-tasks.md

@@ -121,16 +121,17 @@ receiving messages. Pipes are low-level communication building-blocks and so
 come in a variety of forms, each one appropriate for a different use case. In
 what follows, we cover the most commonly used varieties.
 
-The simplest way to create a pipe is to use `Chan::new`
+The simplest way to create a pipe is to use the `comm::stream`
 function to create a `(Port, Chan)` pair. In Rust parlance, a *channel*
 is a sending endpoint of a pipe, and a *port* is the receiving
 endpoint. Consider the following example of calculating two results
 concurrently:
 
 ~~~~
 # use std::task::spawn;
+# use std::comm::{stream, Port, Chan};
 
-let (port, chan): (Port<int>, Chan<int>) = Chan::new();
+let (port, chan): (Port<int>, Chan<int>) = stream();
 
 do spawn || {
     let result = some_expensive_computation();
@@ -149,7 +150,8 @@ stream for sending and receiving integers (the left-hand side of the `let`,
 a tuple into its component parts).
 
 ~~~~
-let (port, chan): (Port<int>, Chan<int>) = Chan::new();
+# use std::comm::{stream, Chan, Port};
+let (port, chan): (Port<int>, Chan<int>) = stream();
 ~~~~
 
 The child task will use the channel to send data to the parent task,
@@ -158,8 +160,9 @@ spawns the child task.
 
 ~~~~
 # use std::task::spawn;
+# use std::comm::stream;
 # fn some_expensive_computation() -> int { 42 }
-# let (port, chan) = Chan::new();
+# let (port, chan) = stream();
 do spawn || {
     let result = some_expensive_computation();
     chan.send(result);
@@ -177,23 +180,25 @@ computation, then waits for the child's result to arrive on the
 port:
 
 ~~~~
+# use std::comm::{stream};
 # fn some_other_expensive_computation() {}
-# let (port, chan) = Chan::<int>::new();
+# let (port, chan) = stream::<int>();
 # chan.send(0);
 some_other_expensive_computation();
 let result = port.recv();
 ~~~~
 
-The `Port` and `Chan` pair created by `Chan::new` enables efficient
-communication between a single sender and a single receiver, but multiple
-senders cannot use a single `Chan`, and multiple receivers cannot use a single
-`Port`.  What if our example needed to compute multiple results across a number
-of tasks? The following program is ill-typed:
+The `Port` and `Chan` pair created by `stream` enables efficient communication
+between a single sender and a single receiver, but multiple senders cannot use
+a single `Chan`, and multiple receivers cannot use a single `Port`.  What if our
+example needed to compute multiple results across a number of tasks? The
+following program is ill-typed:
 
 ~~~ {.xfail-test}
 # use std::task::{spawn};
+# use std::comm::{stream, Port, Chan};
 # fn some_expensive_computation() -> int { 42 }
-let (port, chan) = Chan::new();
+let (port, chan) = stream();
 
 do spawn {
     chan.send(some_expensive_computation());
@@ -211,8 +216,10 @@ Instead we can use a `SharedChan`, a type that allows a single
 
 ~~~
 # use std::task::spawn;
+# use std::comm::{stream, SharedChan};
 
-let (port, chan) = SharedChan::new();
+let (port, chan) = stream();
+let chan = SharedChan::new(chan);
 
 for init_val in range(0u, 3) {
     // Create a new channel handle to distribute to the child task
@@ -231,22 +238,23 @@ Here we transfer ownership of the channel into a new `SharedChan` value.  Like
 as an *affine* or *linear* type). Unlike with `Chan`, though, the programmer
 may duplicate a `SharedChan`, with the `clone()` method.  A cloned
 `SharedChan` produces a new handle to the same channel, allowing multiple
-tasks to send data to a single port.  Between `spawn`, `Chan` and
+tasks to send data to a single port.  Between `spawn`, `stream` and
 `SharedChan`, we have enough tools to implement many useful concurrency
 patterns.
 
 Note that the above `SharedChan` example is somewhat contrived since
-you could also simply use three `Chan` pairs, but it serves to
+you could also simply use three `stream` pairs, but it serves to
 illustrate the point. For reference, written with multiple streams, it
 might look like the example below.
 
 ~~~
 # use std::task::spawn;
+# use std::comm::stream;
 # use std::vec;
 
 // Create a vector of ports, one for each child task
 let ports = vec::from_fn(3, |init_val| {
-    let (port, chan) = Chan::new();
+    let (port, chan) = stream();
     do spawn {
         chan.send(some_expensive_computation(init_val));
     }
@@ -333,7 +341,7 @@ fn main() {
     let numbers_arc = Arc::new(numbers);
 
     for num in range(1u, 10) {
-        let (port, chan)  = Chan::new();
+        let (port, chan)  = stream();
         chan.send(numbers_arc.clone());
 
         do spawn {
@@ -362,7 +370,7 @@ and a clone of it is sent to each task
 # use std::rand;
 # let numbers=vec::from_fn(1000000, |_| rand::random::<f64>());
 # let numbers_arc = Arc::new(numbers);
-# let (port, chan)  = Chan::new();
+# let (port, chan)  = stream();
 chan.send(numbers_arc.clone());
 ~~~
 copying only the wrapper and not its contents.
@@ -374,7 +382,7 @@ Each task recovers the underlying data by
 # use std::rand;
 # let numbers=vec::from_fn(1000000, |_| rand::random::<f64>());
 # let numbers_arc=Arc::new(numbers);
-# let (port, chan)  = Chan::new();
+# let (port, chan)  = stream();
 # chan.send(numbers_arc.clone());
 # let local_arc : Arc<~[f64]> = port.recv();
 let task_numbers = local_arc.get();
@@ -491,7 +499,7 @@ Here is the code for the parent task:
 # }
 # fn main() {
 
-let (from_child, to_child) = DuplexStream::new();
+let (from_child, to_child) = DuplexStream();
 
 do spawn {
     stringifier(&to_child);

branches/try2/src/etc/licenseck.py

@@ -77,7 +77,6 @@
     "rt/isaac/rand.h", # public domain
     "rt/isaac/standard.h", # public domain
     "libstd/rt/mpsc_queue.rs", # BSD
-    "libstd/rt/spsc_queue.rs", # BSD
     "libstd/rt/mpmc_bounded_queue.rs", # BSD
 ]
 

branches/try2/src/libextra/arc.rs

@@ -597,14 +597,15 @@ mod tests {
 
     use arc::*;
 
+    use std::comm;
     use std::task;
 
     #[test]
     fn manually_share_arc() {
         let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
         let arc_v = Arc::new(v);
 
-        let (p, c) = Chan::new();
+        let (p, c) = comm::stream();
 
         do task::spawn {
             let arc_v: Arc<~[int]> = p.recv();
@@ -625,7 +626,7 @@ mod tests {
     fn test_mutex_arc_condvar() {
         let arc = ~MutexArc::new(false);
         let arc2 = ~arc.clone();
-        let (p,c) = Chan::new();
+        let (p,c) = comm::oneshot();
         do task::spawn {
             // wait until parent gets in
             p.recv();
@@ -635,8 +636,9 @@ mod tests {
             })
         }
 
+        let mut c = Some(c);
         arc.access_cond(|state, cond| {
-            c.send(());
+            c.take_unwrap().send(());
             assert!(!*state);
             while !*state {
                 cond.wait();
@@ -648,7 +650,7 @@ mod tests {
     fn test_arc_condvar_poison() {
         let arc = ~MutexArc::new(1);
         let arc2 = ~arc.clone();
-        let (p, c) = Chan::new();
+        let (p, c) = comm::stream();
 
         do spawn {
             let _ = p.recv();
@@ -685,7 +687,7 @@ mod tests {
     pub fn test_mutex_arc_unwrap_poison() {
         let arc = MutexArc::new(1);
         let arc2 = ~(&arc).clone();
-        let (p, c) = Chan::new();
+        let (p, c) = comm::stream();
         do task::spawn {
             arc2.access(|one| {
                 c.send(());
@@ -802,7 +804,7 @@ mod tests {
     fn test_rw_arc() {
         let arc = RWArc::new(0);
         let arc2 = arc.clone();
-        let (p, c) = Chan::new();
+        let (p, c) = comm::stream();
 
         do task::spawn {
             arc2.write(|num| {
@@ -830,7 +832,7 @@ mod tests {
         });
 
         // Wait for children to pass their asserts
-        for r in children.mut_iter() {
+        for r in children.iter() {
             r.recv();
         }
 
@@ -853,7 +855,7 @@ mod tests {
         // Reader tasks
         let mut reader_convos = ~[];
         10.times(|| {
-            let ((rp1, rc1), (rp2, rc2)) = (Chan::new(), Chan::new());
+            let ((rp1, rc1), (rp2, rc2)) = (comm::stream(), comm::stream());
             reader_convos.push((rc1, rp2));
             let arcn = arc.clone();
             do task::spawn {
@@ -867,7 +869,7 @@ mod tests {
 
         // Writer task
         let arc2 = arc.clone();
-        let ((wp1, wc1), (wp2, wc2)) = (Chan::new(), Chan::new());
+        let ((wp1, wc1), (wp2, wc2)) = (comm::stream(), comm::stream());
         do task::spawn || {
             wp1.recv();
             arc2.write_cond(|state, cond| {
@@ -895,14 +897,14 @@ mod tests {
                 assert_eq!(*state, 42);
                 *state = 31337;
                 // send to other readers
-                for &(ref mut rc, _) in reader_convos.mut_iter() {
+                for &(ref rc, _) in reader_convos.iter() {
                     rc.send(())
                 }
             });
             let read_mode = arc.downgrade(write_mode);
             read_mode.read(|state| {
                 // complete handshake with other readers
-                for &(_, ref mut rp) in reader_convos.mut_iter() {
+                for &(_, ref rp) in reader_convos.iter() {
                     rp.recv()
                 }
                 wc1.send(()); // tell writer to try again
@@ -924,7 +926,7 @@ mod tests {
         //     "blk(&Condvar { order: opt_lock, ..*cond })"
         // with just "blk(cond)".
         let x = RWArc::new(true);
-        let (wp, wc) = Chan::new();
+        let (wp, wc) = comm::stream();
 
         // writer task
         let xw = x.clone();
@@ -949,7 +951,7 @@ mod tests {
             });
             // make a reader task to trigger the "reader cloud lock" handoff
             let xr = x.clone();
-            let (rp, rc) = Chan::new();
+            let (rp, rc) = comm::stream();
             do task::spawn {
                 rc.send(());
                 xr.read(|_state| { })