---

yaml
---
r: 141311
b: refs/heads/try2
c: 67283ea
h: refs/heads/master
i:
  141309: bb18b75
  141307: 4dc484a
  141303: 4c54b9c
  141295: c8db5a6
  141279: 58cac24
  141247: 286968c
  141183: 5ed487b
  141055: 821b6ee
  140799: 6f00978
  140287: 29fb8da
  139263: 8878be9
v: v3

Author: thomaslee

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

branches/try2/configure

@@ -555,11 +555,11 @@ then
     CFG_CLANG_VERSION=$("$CFG_CLANG" \
                       --version \
                       | grep version \
-                      | sed 's/.*\(version .*\)/\1/; s/.*based on \(LLVM .*\))/\1/' \
+                      | sed 's/.*\(version .*\)/\1/' \
                       | cut -d ' ' -f 2)
 
     case $CFG_CLANG_VERSION in
-        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3*)
+        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 4.0* | 4.1* | 4.2*)
         step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
         CFG_C_COMPILER="clang"
         ;;

branches/try2/doc/tutorial-tasks.md

@@ -284,7 +284,7 @@ let result = ports.foldl(0, |accum, port| *accum + port.recv() );
 # fn some_expensive_computation(_i: uint) -> int { 42 }
 ~~~
 
-## Backgrounding computations: Futures
+## Futures
 With `extra::future`, rust has a mechanism for requesting a computation and getting the result
 later.
 
@@ -329,77 +329,6 @@ fn main() {
 }
 ~~~
 
-## Sharing immutable data without copy: ARC
-
-To share immutable data between tasks, a first approach would be to only use pipes as we have seen
-previously. A copy of the data to share would then be made for each task. In some cases, this would
-add up to a significant amount of wasted memory and would require copying the same data more than
-necessary.
-
-To tackle this issue, one can use an Atomically Reference Counted wrapper (`ARC`) as implemented in
-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.
-~~~
-use extra::arc::ARC;
-
-fn pnorm(nums: &~[float], p: uint) -> float {
-    (vec::foldl(0.0, *nums, |a,b| a+(*b).pow(p as float) )).pow(1f / (p as float))
-}
-
-fn main() {
-    let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
-    println(fmt!("Inf-norm = %?",  numbers.max()));
-
-    let numbers_arc = ARC(numbers);
-
-    for uint::range(1,10) |num| {
-        let (port, chan)  = stream();
-        chan.send(numbers_arc.clone());
-
-        do spawn {
-            let local_arc : ARC<~[float]> = port.recv();
-            let task_numbers = local_arc.get();
-            println(fmt!("%u-norm = %?", num, pnorm(task_numbers, num)));
-        }
-    }
-}
-~~~
-
-The function `pnorm` performs a simple computation on the vector (it computes the sum of its items
-at the power given as argument and takes the inverse power of this value). The ARC on the vector is
-created by the line
-~~~
-# use extra::arc::ARC;
-# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
-let numbers_arc=ARC(numbers);
-~~~
-and a clone of it is sent to each task
-~~~
-# use extra::arc::ARC;
-# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
-# let numbers_arc = ARC(numbers);
-# let (port, chan)  = stream();
-chan.send(numbers_arc.clone());
-~~~
-copying only the wrapper and not its contents.
-
-Each task recovers the underlying data by
-~~~
-# use extra::arc::ARC;
-# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
-# let numbers_arc=ARC(numbers);
-# let (port, chan)  = stream();
-# chan.send(numbers_arc.clone());
-# let local_arc : ARC<~[float]> = port.recv();
-let task_numbers = local_arc.get();
-~~~
-and can use it as if it were local.
-
-The `arc` module also implements ARCs around mutable data that are not covered here.
-
 # Handling task failure
 
 Rust has a built-in mechanism for raising exceptions. The `fail!()` macro

branches/try2/mk/tests.mk

@@ -284,7 +284,7 @@ define TEST_RUNNER
 # If NO_REBUILD is set then break the dependencies on extra so we can
 # test crates without rebuilding std and extra first
 ifeq ($(NO_REBUILD),)
-STDTESTDEP_$(1)_$(2)_$(3) = $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_EXTRALIB_$(2))
+STDTESTDEP_$(1)_$(2)_$(3) = $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB_$(2))
 else
 STDTESTDEP_$(1)_$(2)_$(3) =
 endif

branches/try2/src/etc/vim/after/ftplugin/rust.vim

@@ -0,0 +1,5 @@
+"Highlight the 100th text column
+"Feature became available in v7.3
+if version >= 703
+    setlocal colorcolumn=100
+endif

branches/try2/src/libextra/arc.rs

@@ -17,7 +17,7 @@
  * In this example, a large vector of floats is shared between several tasks.
  * With simple pipes, without ARC, a copy would have to be made for each task.
  *
- * ~~~ {.rust}
+ * ~~~
  * extern mod std;
  * use std::arc;
  * let numbers=vec::from_fn(100, |ind| (ind as float)*rand::random());
@@ -370,10 +370,7 @@ pub impl<T:Const + Owned> RWARC<T> {
      * See sync::rwlock.write_downgrade(). The RWWriteMode token must be used
      * to obtain the &mut T, and can be transformed into a RWReadMode token by
      * calling downgrade(), after which a &T can be obtained instead.
-     *
-     * # Example
-     *
-     * ~~~ {.rust}
+     * ~~~
      * do arc.write_downgrade |write_mode| {
      *     do (&write_mode).write_cond |state, condvar| {
      *         ... exclusive access with mutable state ...
@@ -510,6 +507,7 @@ mod tests {
     use core::prelude::*;
     use core::cell::Cell;
     use arc::*;
+    use arc;
 
     #[test]
     fn manually_share_arc() {

branches/try2/src/libextra/base64.rs

@@ -28,17 +28,17 @@ impl<'self> ToBase64 for &'self [u8] {
     /**
      * Turn a vector of `u8` bytes into a base64 string.
      *
-     * # Example
+     * *Example*:
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = [52,32].to_base64();
      *     println(fmt!("%s", str));
      * }
-     * ~~~
+     * ~~~~
      */
     fn to_base64(&self) -> ~str {
         let mut s = ~"";
@@ -91,17 +91,17 @@ impl<'self> ToBase64 for &'self str {
      * Convert any string (literal, `@`, `&`, or `~`) to base64 encoding.
      *
      *
-     * # Example
+     * *Example*:
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = "Hello, World".to_base64();
      *     println(fmt!("%s",str));
      * }
-     * ~~~
+     * ~~~~
      *
      */
     fn to_base64(&self) -> ~str {
@@ -118,9 +118,9 @@ impl FromBase64 for ~[u8] {
      * Convert base64 `u8` vector into u8 byte values.
      * Every 4 encoded characters is converted into 3 octets, modulo padding.
      *
-     * # Example
+     * *Example*:
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      * use std::base64::FromBase64;
@@ -131,7 +131,7 @@ impl FromBase64 for ~[u8] {
      *     let bytes = str.from_base64();
      *     println(fmt!("%?",bytes));
      * }
-     * ~~~
+     * ~~~~
      */
     fn from_base64(&self) -> ~[u8] {
         if self.len() % 4u != 0u { fail!("invalid base64 length"); }
@@ -196,11 +196,11 @@ impl FromBase64 for ~str {
      * You can use the `from_bytes` function in `core::str`
      * to turn a `[u8]` into a string with characters corresponding to those values.
      *
-     * # Example
+     * *Example*:
      *
      * This converts a string literal to base64 and back.
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      * use std::base64::FromBase64;
@@ -214,7 +214,7 @@ impl FromBase64 for ~str {
      *     let result_str = str::from_bytes(bytes);
      *     println(fmt!("%s",result_str));
      * }
-     * ~~~
+     * ~~~~
      */
     fn from_base64(&self) -> ~[u8] {
         str::to_bytes(*self).from_base64()

branches/try2/src/libextra/bitv.rs

@@ -1197,7 +1197,7 @@ mod tests {
     #[test]
     fn test_from_bytes() {
         let bitv = from_bytes([0b10110110, 0b00000000, 0b11111111]);
-        let str = ~"10110110" + "00000000" + "11111111";
+        let str = ~"10110110" + ~"00000000" + ~"11111111";
         assert_eq!(bitv.to_str(), str);
     }
 

branches/try2/src/libextra/deque.rs

@@ -125,31 +125,6 @@ pub impl<T> Deque<T> {
         self.hi = (self.hi + 1u) % self.elts.len();
         self.nelts += 1u;
     }
-
-    /// Reserve capacity for exactly `n` elements in the given deque,
-    /// doing nothing if `self`'s capacity is already equal to or greater
-    /// than the requested capacity
-    ///
-    /// # Arguments
-    ///
-    /// * n - The number of elements to reserve space for
-    fn reserve(&mut self, n: uint) {
-        vec::reserve(&mut self.elts, n);
-    }
-
-    /// Reserve capacity for at least `n` elements in the given deque,
-    /// over-allocating in case the caller needs to reserve additional
-    /// space.
-    ///
-    /// Do nothing if `self`'s capacity is already equal to or greater
-    /// than the requested capacity.
-    ///
-    /// # Arguments
-    ///
-    /// * n - The number of elements to reserve space for
-    fn reserve_at_least(&mut self, n: uint) {
-        vec::reserve_at_least(&mut self.elts, n);
-    }
 }
 
 /// Grow is only called on full elts, so nelts is also len(elts), unlike
@@ -174,7 +149,6 @@ mod tests {
     use super::*;
     use core::cmp::Eq;
     use core::kinds::Copy;
-    use core::vec::capacity;
 
     #[test]
     fn test_simple() {
@@ -354,29 +328,4 @@ mod tests {
         }
 
     }
-
-    #[test]
-    fn test_reserve() {
-        let mut d = Deque::new();
-        d.add_back(0u64);
-        d.reserve(50);
-        assert_eq!(capacity(&mut d.elts), 50);
-        let mut d = Deque::new();
-        d.add_back(0u32);
-        d.reserve(50);
-        assert_eq!(capacity(&mut d.elts), 50);
-    }
-
-    #[test]
-    fn test_reserve_at_least() {
-        let mut d = Deque::new();
-        d.add_back(0u64);
-        d.reserve_at_least(50);
-        assert_eq!(capacity(&mut d.elts), 64);
-        let mut d = Deque::new();
-        d.add_back(0u32);
-        d.reserve_at_least(50);
-        assert_eq!(capacity(&mut d.elts), 64);
-    }
-
 }

branches/try2/src/libextra/flatpipes.rs

@@ -25,7 +25,7 @@ ports and channels.
 
 This example sends boxed integers across tasks using serialization.
 
-~~~ {.rust}
+~~~
 let (port, chan) = serial::pipe_stream();
 
 do task::spawn || {
@@ -927,7 +927,7 @@ mod test {
         fn test_try_recv_none3<P:BytePort>(loader: PortLoader<P>) {
             static CONTINUE: [u8, ..4] = [0xAA, 0xBB, 0xCC, 0xDD];
             // The control word is followed by garbage
-            let bytes = CONTINUE.to_vec() + [0];
+            let bytes = CONTINUE.to_vec() + ~[0];
             let port = loader(bytes);
             let res: Option<int> = port.try_recv();
             assert!(res.is_none());
@@ -951,7 +951,7 @@ mod test {
                     1, sys::size_of::<u64>()) |len_bytes| {
                     len_bytes.to_vec()
                 };
-                let bytes = CONTINUE.to_vec() + len_bytes + [0, 0, 0, 0];
+                let bytes = CONTINUE.to_vec() + len_bytes + ~[0, 0, 0, 0];
 
                 let port = loader(bytes);
 

branches/try2/src/libextra/future.rs

@@ -14,7 +14,7 @@
  *
  * # Example
  *
- * ~~~ {.rust}
+ * ~~~
  * # fn fib(n: uint) -> uint {42};
  * # fn make_a_sandwich() {};
  * let mut delayed_fib = std::future::spawn (|| fib(5000) );

branches/try2/src/libextra/json.rs

@@ -1880,13 +1880,13 @@ mod tests {
                   ]));
         assert_eq!(result::unwrap(from_str(
                       ~"{" +
-                          "\"a\": 1.0, " +
-                          "\"b\": [" +
-                              "true," +
-                              "\"foo\\nbar\", " +
-                              "{ \"c\": {\"d\": null} } " +
-                          "]" +
-                      "}")),
+                          ~"\"a\": 1.0, " +
+                          ~"\"b\": [" +
+                              ~"true," +
+                              ~"\"foo\\nbar\", " +
+                              ~"{ \"c\": {\"d\": null} } " +
+                          ~"]" +
+                      ~"}")),
                   mk_object([
                       (~"a", Number(1.0f)),
                       (~"b", List(~[

branches/try2/src/libextra/net_ip.rs

@@ -375,6 +375,7 @@ mod test {
     use uv;
 
     use core::result;
+    use core::vec;
 
     #[test]
     fn test_ip_ipv4_parse_and_format_ip() {