---

yaml
---
r: 81983
b: refs/heads/master
c: 5d24a1a
h: refs/heads/master
i:
  81981: 934626d
  81979: 3f3c8ff
  81975: 786e615
  81967: ee18e2e
  81951: 025ca15
  81919: 274cca6
v: v3

Author: MicahChalmer

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 6c8e6aad7344a62d91d5cf10e0dd1769602a5257
+refs/heads/master: 5d24a1ae45189b8222ce84084eaae3ff8b7d67d0
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/doc/tutorial.md

@@ -737,7 +737,7 @@ fn area(sh: Shape) -> float {
     match sh {
         Circle { radius: radius, _ } => float::consts::pi * square(radius),
         Rectangle { top_left: top_left, bottom_right: bottom_right } => {
-            (bottom_right.x - top_left.x) * (bottom_right.y - top_left.y)
+            (bottom_right.x - top_left.x) * (top_left.y - bottom_right.y) 
         }
     }
 }
@@ -923,60 +923,22 @@ custom destructors.
 
 # Boxes
 
-A value in Rust is stored directly inside the owner. If a `struct` contains
-four `int` fields, it will be four times as large as a single `int`.  The
-following `struct` type is invalid, as it would have an infinite size:
+Many modern languages represent values as pointers to heap memory by
+default. In contrast, Rust, like C and C++, represents such types directly.
+Another way to say this is that aggregate data in Rust are *unboxed*. This
+means that if you `let x = Point { x: 1f, y: 1f };`, you are creating a struct
+on the stack. If you then copy it into a data structure, you copy the entire
+struct, not just a pointer.
 
-~~~~ {.xfail-test}
-struct List {
-    next: Option<List>,
-    data: int
-}
-~~~~
-
-> ***Note:*** The `Option` type is an enum representing an *optional* value.
-> It's comparable to a nullable pointer in many other languages, but stores the
-> contained value unboxed.
-
-An *owned box* (`~`) uses a heap allocation to provide the invariant of always
-being the size of a pointer, regardless of the contained type. This can be
-leveraged to create a valid recursive `struct` type with a finite size:
-
-~~~~
-struct List {
-    next: Option<~List>,
-    data: int
-}
-~~~~
-
-Since an owned box has a single owner, they are limited to representing
-tree-like data structures.
-
-The most common use case for owned boxes is creating recursive data structures
-like a binary search tree. Rust's trait-based generics system (covered later in
-the tutorial) is usually used for static dispatch, but also provides dynamic
-dispatch via boxing. Values of different types may have different sizes, but a
-box is able to *erase* the difference via the layer of indirection they
-provide.
+For small structs like `Point`, this is usually more efficient than allocating
+memory and indirecting through a pointer. But for big structs, or mutable
+state, it can be useful to have a single copy on the stack or on the heap, and
+refer to that through a pointer.
 
-In uncommon cases, the indirection can provide a performance gain or memory
-reduction by making values smaller. However, unboxed values should almost
-always be preferred.
+## Owned boxes
 
-Note that returning large unboxed values via boxes is unnecessary. A large
-value is returned via a hidden output parameter, and the decision on where to
-place the return value should be left to the caller:
-
-~~~~
-fn foo() -> (int, int, int, int, int, int) {
-    (5, 5, 5, 5, 5, 5)
-}
-
-let x = ~foo(); // allocates, and writes the integers directly to it
-~~~~
-
-Beyond the properties granted by the size, an owned box behaves as a regular
-value by inheriting the mutability and lifetime of the owner:
+An owned box (`~`) is a uniquely owned allocation on the heap. It inherits the
+mutability and lifetime of the owner as it would if there was no box:
 
 ~~~~
 let x = 5; // immutable
@@ -988,33 +950,35 @@ let mut y = ~5; // mutable
 *y += 2; // the * operator is needed to access the contained value
 ~~~~
 
-As covered earlier, an owned box has a destructor to clean up the allocated
-memory. This makes it more restricted than an unboxed type with no destructor
-by introducing *move semantics*.
+The purpose of an owned box is to add a layer of indirection in order to create
+recursive data structures or cheaply pass around an object larger than a
+pointer. Since an owned box has a unique owner, it can only be used to
+represent a tree data structure.
 
-# Move semantics
+The following struct won't compile, because the lack of indirection would mean
+it has an infinite size:
 
-Rust uses a shallow copy for parameter passing, assignment and returning from
-functions. This is considered a move of ownership for types with destructors.
-After a value has been moved, it can no longer be used from the source location
-and will not be destroyed when the source goes out of scope.
-
-~~~~
-let x = ~5;
-let y = x.clone(); // y is a newly allocated box
-let z = x; // no new memory allocated, x can no longer be used
+~~~~ {.xfail-test}
+struct Foo {
+    child: Option<Foo>
+}
 ~~~~
 
-The mutability of a value may be changed by moving it to a new owner:
+> ***Note:*** The `Option` type is an enum that represents an *optional* value.
+> It's comparable to a nullable pointer in many other languages, but stores the
+> contained value unboxed.
+
+Adding indirection with an owned pointer allocates the child outside of the
+struct on the heap, which makes it a finite size and won't result in a
+compile-time error:
 
 ~~~~
-let r = ~13;
-let mut s = r; // box becomes mutable
-*s += 1;
-let t = s; // box becomes immutable
+struct Foo {
+    child: Option<~Foo>
+}
 ~~~~
 
-# Managed boxes
+## Managed boxes
 
 A managed box (`@`) is a heap allocation with the lifetime managed by a
 task-local garbage collector. It will be destroyed at some point after there
@@ -1059,6 +1023,30 @@ d = b;          // box type is the same, okay
 c = b;          // error
 ~~~~
 
+# Move semantics
+
+Rust uses a shallow copy for parameter passing, assignment and returning values
+from functions. A shallow copy is considered a move of ownership if the
+ownership tree of the copied value includes an owned box or a type with a
+custom destructor. After a value has been moved, it can no longer be used from
+the source location and will not be destroyed there.
+
+~~~~
+let x = ~5;
+let y = x.clone(); // y is a newly allocated box
+let z = x; // no new memory allocated, x can no longer be used
+~~~~
+
+Since in owned boxes mutability is a property of the owner, not the
+box, mutable boxes may become immutable when they are moved, and vice-versa.
+
+~~~~
+let r = ~13;
+let mut s = r; // box becomes mutable
+*s += 1;
+let t = s; // box becomes immutable
+~~~~
+
 # Borrowed pointers
 
 Rust's borrowed pointers are a general purpose reference type. In contrast with

trunk/src/etc/emacs/rust-mode-tests.el

@@ -196,6 +196,35 @@ This is some more text.  Fee fie fo fum.  Humpty dumpty sat on a wall.
  *very very very long string
  */"))
 
+(ert-deftest fill-paragraph-single-line-style-with-code-before ()
+  (test-fill-paragraph
+   "fn foo() { }
+/// This is my comment.  This is more of my comment.  This is even more."
+   "fn foo() { }
+/// This is my comment.  This is
+/// more of my comment.  This is
+/// even more." 14))
+
+(ert-deftest fill-paragraph-single-line-style-with-code-after ()
+  (test-fill-paragraph
+   "/// This is my comment.  This is more of my comment.  This is even more.
+fn foo() { }"
+   "/// This is my comment.  This is
+/// more of my comment.  This is
+/// even more.
+fn foo() { }" 1 73))
+
+(ert-deftest fill-paragraph-single-line-style-code-before-and-after ()
+  (test-fill-paragraph
+   "fn foo() { }
+/// This is my comment.  This is more of my comment.  This is even more.
+fn bar() { }"
+   "fn foo() { }
+/// This is my comment.  This is
+/// more of my comment.  This is
+/// even more.
+fn bar() { }" 14 67))
+
 (defun test-auto-fill (initial position inserted expected)
   (rust-test-manip-code 
    initial

trunk/src/etc/emacs/rust-mode.el

@@ -300,7 +300,8 @@
         (let
             ((fill-paragraph-function
               (if (not (eq fill-paragraph-function 'rust-fill-paragraph))
-                  fill-paragraph-function)))
+                  fill-paragraph-function))
+             (fill-paragraph-handle-comment t))
           (apply 'fill-paragraph args)
           t))))))
 

trunk/src/librustc/middle/check_match.rs

@@ -773,12 +773,12 @@ pub fn specialize(cx: &MatchCheckCtxt,
                         let num_elements = before.len() + after.len();
                         if num_elements < arity && slice.is_some() {
                             Some(vec::append(
-                                vec::concat(&[
+                                [
                                     before,
                                     vec::from_elem(
                                         arity - num_elements, wild()),
                                     after
-                                ]),
+                                ].concat_vec(),
                                 r.tail()
                             ))
                         } else if num_elements == arity {

trunk/src/librustdoc/clean.rs

@@ -173,12 +173,11 @@ impl Clean<Item> for doctree::Module {
             visibility: self.vis.clean(),
             id: self.id,
             inner: ModuleItem(Module {
-               items: std::vec::concat(&[self.structs.clean(),
-                              self.enums.clean(), self.fns.clean(),
-                              std::vec::concat(self.foreigns.clean()),
-                              self.mods.clean(), self.typedefs.clean(),
-                              self.statics.clean(), self.traits.clean(),
-                              self.impls.clean(), self.view_items.clean()])
+               items: [self.structs.clean(), self.enums.clean(),
+                       self.fns.clean(), self.foreigns.clean().concat_vec(),
+                       self.mods.clean(), self.typedefs.clean(),
+                       self.statics.clean(), self.traits.clean(),
+                       self.impls.clean(), self.view_items.clean()].concat_vec()
             })
         }
     }

trunk/src/libstd/rt/sched.rs

@@ -1280,7 +1280,6 @@ mod test {
     // FIXME: #9407: xfail-test
     fn dont_starve_1() {
         use rt::comm::oneshot;
-        use unstable::running_on_valgrind;
 
         do stress_factor().times {
             do run_in_mt_newsched_task {

trunk/src/libstd/vec.rs

@@ -340,59 +340,36 @@ pub fn flat_map<T, U>(v: &[T], f: &fn(t: &T) -> ~[U]) -> ~[U] {
     result
 }
 
-/// Flattens a vector of vectors of T into a single vector of T.
-pub fn concat<T:Clone>(v: &[~[T]]) -> ~[T] { v.concat_vec() }
-
-/// Concatenate a vector of vectors, placing a given separator between each
-pub fn connect<T:Clone>(v: &[~[T]], sep: &T) -> ~[T] { v.connect_vec(sep) }
-
-/// Flattens a vector of vectors of T into a single vector of T.
-pub fn concat_slices<T:Clone>(v: &[&[T]]) -> ~[T] { v.concat_vec() }
-
-/// Concatenate a vector of vectors, placing a given separator between each
-pub fn connect_slices<T:Clone>(v: &[&[T]], sep: &T) -> ~[T] { v.connect_vec(sep) }
-
 #[allow(missing_doc)]
 pub trait VectorVector<T> {
     // FIXME #5898: calling these .concat and .connect conflicts with
     // StrVector::con{cat,nect}, since they have generic contents.
+    /// Flattens a vector of vectors of T into a single vector of T.
     fn concat_vec(&self) -> ~[T];
-    fn connect_vec(&self, sep: &T) -> ~[T];
-}
-
-impl<'self, T:Clone> VectorVector<T> for &'self [~[T]] {
-    /// Flattens a vector of slices of T into a single vector of T.
-    fn concat_vec(&self) -> ~[T] {
-        self.flat_map(|inner| (*inner).clone())
-    }
 
     /// Concatenate a vector of vectors, placing a given separator between each.
-    fn connect_vec(&self, sep: &T) -> ~[T] {
-        let mut r = ~[];
-        let mut first = true;
-        for inner in self.iter() {
-            if first { first = false; } else { r.push((*sep).clone()); }
-            r.push_all((*inner).clone());
-        }
-        r
-    }
+    fn connect_vec(&self, sep: &T) -> ~[T];
 }
 
-impl<'self,T:Clone> VectorVector<T> for &'self [&'self [T]] {
-    /// Flattens a vector of slices of T into a single vector of T.
+impl<'self, T: Clone, V: Vector<T>> VectorVector<T> for &'self [V] {
     fn concat_vec(&self) -> ~[T] {
-        self.flat_map(|&inner| inner.to_owned())
+        let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len());
+        let mut result = with_capacity(size);
+        for v in self.iter() {
+            result.push_all(v.as_slice())
+        }
+        result
     }
 
-    /// Concatenate a vector of slices, placing a given separator between each.
     fn connect_vec(&self, sep: &T) -> ~[T] {
-        let mut r = ~[];
+        let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len());
+        let mut result = with_capacity(size + self.len());
         let mut first = true;
-        for &inner in self.iter() {
-            if first { first = false; } else { r.push((*sep).clone()); }
-            r.push_all(inner);
+        for v in self.iter() {
+            if first { first = false } else { result.push(sep.clone()) }
+            result.push_all(v.as_slice())
         }
-        r
+        result
     }
 }
 
@@ -3109,24 +3086,21 @@ mod tests {
 
     #[test]
     fn test_concat() {
-        assert_eq!(concat([~[1], ~[2,3]]), ~[1, 2, 3]);
+        let v: [~[int], ..0] = [];
+        assert_eq!(v.concat_vec(), ~[]);
         assert_eq!([~[1], ~[2,3]].concat_vec(), ~[1, 2, 3]);
 
-        assert_eq!(concat_slices([&[1], &[2,3]]), ~[1, 2, 3]);
         assert_eq!([&[1], &[2,3]].concat_vec(), ~[1, 2, 3]);
     }
 
     #[test]
     fn test_connect() {
-        assert_eq!(connect([], &0), ~[]);
-        assert_eq!(connect([~[1], ~[2, 3]], &0), ~[1, 0, 2, 3]);
-        assert_eq!(connect([~[1], ~[2], ~[3]], &0), ~[1, 0, 2, 0, 3]);
+        let v: [~[int], ..0] = [];
+        assert_eq!(v.connect_vec(&0), ~[]);
         assert_eq!([~[1], ~[2, 3]].connect_vec(&0), ~[1, 0, 2, 3]);
         assert_eq!([~[1], ~[2], ~[3]].connect_vec(&0), ~[1, 0, 2, 0, 3]);
 
-        assert_eq!(connect_slices([], &0), ~[]);
-        assert_eq!(connect_slices([&[1], &[2, 3]], &0), ~[1, 0, 2, 3]);
-        assert_eq!(connect_slices([&[1], &[2], &[3]], &0), ~[1, 0, 2, 0, 3]);
+        assert_eq!(v.connect_vec(&0), ~[]);
         assert_eq!([&[1], &[2, 3]].connect_vec(&0), ~[1, 0, 2, 3]);
         assert_eq!([&[1], &[2], &[3]].connect_vec(&0), ~[1, 0, 2, 0, 3]);
     }
@@ -3758,7 +3732,9 @@ mod tests {
 #[cfg(test)]
 mod bench {
     use extra::test::BenchHarness;
+    use iter::range;
     use vec;
+    use vec::VectorVector;
     use option::*;
 
     #[bench]
@@ -3798,4 +3774,20 @@ mod bench {
             xs + ys;
         }
     }
+
+    #[bench]
+    fn concat(bh: &mut BenchHarness) {
+        let xss: &[~[uint]] = vec::from_fn(100, |i| range(0, i).collect());
+        do bh.iter {
+            xss.concat_vec();
+        }
+    }
+
+    #[bench]
+    fn connect(bh: &mut BenchHarness) {
+        let xss: &[~[uint]] = vec::from_fn(100, |i| range(0, i).collect());
+        do bh.iter {
+            xss.connect_vec(&0);
+        }
+    }
 }