---

yaml
---
r: 134703
b: refs/heads/try
c: 64813d3
h: refs/heads/master
i:
  134701: b13d986
  134699: 5469dd6
  134695: bef3164
  134687: 69a8cec
v: v3

Author: steveklabnik

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 58413c09cd52ea4005d6ea7733ba1fb3a8f36589
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 437179ed8bf7f7672f84b19265df1ce569e70490
-refs/heads/try: c94d479a90ab4e99926ac218d1b2329056c7e04b
+refs/heads/try: 64813d33d825cbd155ef237accc9fe8c8b670ed2
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/reference.md

@@ -2810,9 +2810,8 @@ array_expr : '[' "mut" ? vec_elems? ']' ;
 array_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
 ```
 
-An [array](#vector,-array,-and-slice-types) _expression_ is written by
-enclosing zero or more comma-separated expressions of uniform type in square
-brackets.
+An [array](#array,-and-slice-types) _expression_ is written by enclosing zero
+or more comma-separated expressions of uniform type in square brackets.
 
 In the `[expr ',' ".." expr]` form, the expression after the `".."` must be a
 constant expression that can be evaluated at compile time, such as a
@@ -2831,7 +2830,7 @@ constant expression that can be evaluated at compile time, such as a
 idx_expr : expr '[' expr ']' ;
 ```
 
-[Array](#vector,-array,-and-slice-types)-typed expressions can be indexed by
+[Array](#array,-and-slice-types)-typed expressions can be indexed by
 writing a square-bracket-enclosed expression (the index) after them. When the
 array is mutable, the resulting [lvalue](#lvalues,-rvalues-and-temporaries) can
 be assigned to.
@@ -3551,23 +3550,17 @@ let (a, b) = p;
 assert!(b != "world");
 ```
 
-### Vector, Array, and Slice types
+### Array, and Slice types
 
-Rust has three different types for a list of items:
+Rust has two different types for a list of items:
 
-* `Vec<T>`, a 'vector'
 * `[T ..N]`, an 'array'
 * `&[T]`, a 'slice'.
 
-A vector is a heap-allocated list of `T`. A vector has ownership over the data
-inside of it. It is also able to grow and change in size. It's important to
-note that `Vec<T>` is a library type, it's not actually part of the core
-language.
-
 An array has a fixed size, and can be allocated on either the stack or the
 heap.
 
-A slice is a 'view' into a vector or array. It doesn't own the data it points
+A slice is a 'view' into an array. It doesn't own the data it points
 to, it borrows it.
 
 An example of each kind:
@@ -3581,8 +3574,8 @@ let s: &[int]      = vec.as_slice();
 As you can see, the `vec!` macro allows you to create a `Vec<T>` easily. The
 `vec!` macro is also part of the standard library, rather than the language.
 
-All in-bounds elements of vectors, arrays, and slices are always initialized,
-and access to a vector, array, or slice is always bounds-checked.
+All in-bounds elements of arrays, and slices are always initialized, and access
+to an array or slice is always bounds-checked.
 
 ### Structure types
 
@@ -3644,7 +3637,7 @@ enclosing `enum` or `struct` type itself. Such recursion has restrictions:
 
 * Recursive types must include a nominal type in the recursion
   (not mere [type definitions](#type-definitions),
-   or other structural types such as [arrays](#vector,-array,-and-slice-types) or [tuples](#tuple-types)).
+   or other structural types such as [arrays](#array,-and-slice-types) or [tuples](#tuple-types)).
 * A recursive `enum` item must have at least one non-recursive constructor
   (in order to give the recursion a basis case).
 * The size of a recursive type must be finite;