auto merge of #5553 : pnkfelix/rust/doc-fixes-for-0.6-incoming, r=sanxiyn

4 files changed, 38 insertions, 7 deletions

diff --git a/doc/rust.md b/doc/rust.md
index 60a83662b0e..3847b0b9755 100644
--- a/doc/rust.md
+++ b/doc/rust.md
@@ -1671,6 +1671,10 @@ vec_elems : [expr [',' expr]*] | [expr ',' ".." expr]
 A [_vector_](#vector-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 [literal](#literals) or a [static item](#static-items).
+
 ~~~~
 [1, 2, 3, 4];
 ["a", "b", "c", "d"];
@@ -2156,6 +2160,19 @@ do f |j| {
 }
 ~~~~
 
+In this example, both calls to the (binary) function `k` are equivalent:
+
+~~~~
+# fn k(x:int, f: &fn(int)) { }
+# fn l(i: int) { }
+
+k(3, |j| l(j));
+
+do k(3) |j| {
+   l(j);
+}
+~~~~
+
 
 ### For expressions
 
@@ -2184,7 +2201,7 @@ and early boolean-valued returns from the `block` function,
 such that the meaning of `break` and `loop` is preserved in a primitive loop
 when rewritten as a `for` loop controlled by a higher order function.
 
-An example a for loop:
+An example of a for loop over the contents of a vector:
 
 ~~~~
 # type foo = int;
@@ -2198,6 +2215,14 @@ for v.each |e| {
 }
 ~~~~
 
+An example of a for loop over a series of integers:
+
+~~~~
+# fn bar(b:uint) { }
+for uint::range(0, 256) |i| {
+    bar(i);
+}
+~~~~
 
 ### If expressions
 
@@ -2474,6 +2499,7 @@ fail_unless!(b != "world");
 
 The vector type constructor represents a homogeneous array of values of a given type.
 A vector has a fixed size.
+(Operations like `vec::push` operate solely on owned vectors.)
 A vector type can be annotated with a _definite_ size,
 written with a trailing asterisk and integer literal, such as `[int * 10]`.
 Such a definite-sized vector type is a first-class type, since its size is known statically.
@@ -2484,6 +2510,10 @@ such as `&[T]`, `@[T]` or `~[T]`.
 The kind of a vector type depends on the kind of its element type,
 as with other simple structural types.
 
+Expressions producing vectors of definite size cannot be evaluated in a
+context expecting a vector of indefinite size; one must copy the
+definite-sized vector contents into a distinct vector of indefinite size.
+
 An example of a vector type and its use:
 
 ~~~~
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index f94c62d23ec..58a514dc0ee 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -284,7 +284,8 @@ pub fn build_sized_opt<A,B: Buildable<A>>(size: Option<uint>,
 
 // Functions that combine iteration and building
 
-/// Applies a function to each element of an iterable and returns the results.
+/// Applies a function to each element of an iterable and returns the results
+/// in a sequence built via `BU`.  See also `map_to_vec`.
 #[inline(always)]
 pub fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: &fn(&T) -> U)
     -> BU {
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 9def28fd3aa..5c976756d13 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -172,12 +172,12 @@ pub fn with_capacity<T>(capacity: uint) -> ~[T] {
 /**
  * Builds a vector by calling a provided function with an argument
  * function that pushes an element to the back of a vector.
- * This version takes an initial size for the vector.
+ * This version takes an initial capacity for the vector.
  *
  * # Arguments
  *
  * * size - An initial size of the vector to reserve
- * * builder - A function that will construct the vector. It recieves
+ * * builder - A function that will construct the vector. It receives
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */
@@ -194,7 +194,7 @@ pub fn build_sized<A>(size: uint, builder: &fn(push: &fn(v: A))) -> ~[A] {
  *
  * # Arguments
  *
- * * builder - A function that will construct the vector. It recieves
+ * * builder - A function that will construct the vector. It receives
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */
diff --git a/src/librustc/README.txt b/src/librustc/README.txt
index e61714c0dd2..9ac35aa4448 100644
--- a/src/librustc/README.txt
+++ b/src/librustc/README.txt
@@ -32,8 +32,8 @@ lib/      - bindings to LLVM
 The files concerned purely with syntax -- that is, the AST, parser,
 pretty-printer, lexer, macro expander, and utilities for traversing
 ASTs -- are in a separate crate called "syntax", whose files are in
-./../libsyntax if the parent directory of front/, middle/, back/, and
-so on is . .
+./../libsyntax, where . is the current directory (that is, the parent
+directory of front/, middle/, back/, and so on).
 
 The entry-point for the compiler is main() in driver/rustc.rs, and
 this file sequences the various parts together.