code review 14415043: spec: clarify rules for blank identifiers

doc/go_spec.html

 <!--{
         "Title": "The Go Programming Language Specification",
-        "Subtitle": "Version of Oct 7, 2013",
+        "Subtitle": "Version of Nov 13, 2013",
         "Path": "/ref/spec"
 }-->
 
 <!--
 TODO
 [ ] need language about function/method calls and parameter passing rules
 [ ] last paragraph of #Assignments (constant promotion) should be elsewhere
     and mention assignment to empty interface.
 [ ] need to say something about "scope" of selectors?
 [ ] clarify what a field name is in struct declarations
@@ skipping 818 matching lines @@
 [32]byte
 [2*N] struct { x, y int32 }
 [1000]*float64
 [3][5]int
 [2][2][2]float64  // same as [2]([2]([2]float64))
 </pre>
 
 <h3 id="Slice_types">Slice types</h3>
 
 <p>
-A slice is a descriptor for a contiguous segment of an array and
+A slice is a descriptor for a contiguous segment of an <i>underlying array</i> and
 provides access to a numbered sequence of elements from that array.
 A slice type denotes the set of all slices of arrays of its element type.
 The value of an uninitialized slice is <code>nil</code>.
 </p>
 
 <pre class="ebnf">
 SliceType = "[" "]" ElementType .
 </pre>
 
 <p>
@@ skipping 19 matching lines @@
 <a href="#Slice_expressions"><i>slicing</i></a> a new one from the original slice.
 The capacity of a slice <code>a</code> can be discovered using the
 built-in function <a href="#Length_and_capacity"><code>cap(a)</code></a>.
 </p>
 
 <p>
 A new, initialized slice value for a given element type <code>T</code> is
 made using the built-in function
 <a href="#Making_slices_maps_and_channels"><code>make</code></a>,
 which takes a slice type
-and parameters specifying the length and optionally the capacity:
-</p>
-
-<pre>
-make([]T, length)
+and parameters specifying the length and optionally the capacity.
+A slice created with <code>make</code> always allocates a new, hidden array
+to which the returned slice value refers. That is, executing
+</p>
+
+<pre>
 make([]T, length, capacity)
 </pre>
 
 <p>
-A call to <code>make</code> allocates a new, hidden array to which the returned
-slice value refers. That is, executing
-</p>
-
-<pre>
-make([]T, length, capacity)
-</pre>
-
-<p>
-produces the same slice as allocating an array and slicing it, so these two examples
-result in the same slice:
+produces the same slice as allocating an array and <a href="#Slice_expressions">slicing</a>
+it, so these two expressions are equivalent:
 </p>
 
 <pre>
 make([]int, 50, 100)
 new([100]int)[0:50]
 </pre>
 
 <p>
 Like arrays, slices are always one-dimensional but may be composed to construct
 higher-dimensional objects.
 With arrays of arrays, the inner arrays are, by construction, always the same length;
-however with slices of slices (or arrays of slices), the lengths may vary dynamically.
-Moreover, the inner slices must be allocated individually (with <code>make</code>).
+however with slices of slices (or arrays of slices), the inner lengths may vary dynamically.
+Moreover, the inner slices must be initialized individually.
 </p>
 
 <h3 id="Struct_types">Struct types</h3>
 
 <p>
 A struct is a sequence of named elements, called fields, each of which has a
 name and a type. Field names may be specified explicitly (IdentifierList) or
 implicitly (AnonymousField).
 Within a struct, non-<a href="#Blank_identifier">blank</a> field names must
 be <a href="#Uniqueness_of_identifiers">unique</a>.
@@ skipping 662 matching lines @@
 In contrast to other identifiers, labels are not block scoped and do
 not conflict with identifiers that are not labels. The scope of a label
 is the body of the function in which it is declared and excludes
 the body of any nested function.
 </p>
 
 
 <h3 id="Blank_identifier">Blank identifier</h3>
 
 <p>
-The <i>blank identifier</i> is the underscore character <code>_</code>.

[r, 2013/10/07 22:08:07]

s/is/is represented by/

[gri, 2013/10/07 22:26:14]

Done.

+The <i>blank identifier</i> is represented by the underscore character <code>_</code>.
 It serves as an anonymous placeholder instead of a regular (non-blank)
 identifier and has special meaning in <a href="#Declarations_and_scope">declarations</a>,
 as an <a href="#Operands">operand</a>, and in <a href="#Assignments">assignments</a>.
 </p>
 
 
 <h3 id="Predeclared_identifiers">Predeclared identifiers</h3>
 
 <p>
 The following identifiers are implicitly declared in the
@@ skipping 1100 matching lines @@
 <p>
 Except for <a href="#Constants">untyped strings</a>, if the sliced operand is a string or slice,
 the result of the slice operation is a non-constant value of the same type as the operand.
 For untyped string operands the result is a non-constant value of type <code>string</code>.
 If the sliced operand is an array, it must be <a href="#Address_operators">addressable</a>
 and the result of the slice operation is a slice with the same element type as the array.
 </p>
 
 <p>
 If the sliced operand of a valid slice expression is a <code>nil</code> slice, the result
-is a <code>nil</code> slice.
+is a <code>nil</code> slice. Otherwise, the result shares its underlying array with the
+operand.
 </p>
 
 <h4>Full slice expressions</h4>
 
 <p>
 For an array, pointer to array, or slice <code>a</code> (but not a string), the primary expression
 </p>
 
 <pre>
 a[low : high : max]
@@ skipping 1548 matching lines @@
 
 <pre>
 x = 1
 *p = f()
 a[i] = 23
 (k) = &lt;-ch  // same as: k = &lt;-ch
 </pre>
 
 <p>
 An <i>assignment operation</i> <code>x</code> <i>op</i><code>=</code>
-<code>y</code> where <i>op</i> is a binary arithmetic operation is equivalent

[r, 2013/10/07 22:08:07]

s2/is//

[gri, 2013/10/07 22:26:14]

Done.

+<code>y</code> where <i>op</i> is a binary arithmetic operation equivalent
 to <code>x</code> <code>=</code> <code>x</code> <i>op</i>
 <code>y</code> but evaluates <code>x</code>
 only once.  The <i>op</i><code>=</code> construct is a single token.
 In assignment operations, both the left- and right-hand expression lists
 must contain exactly one single-valued expression, and the left-hand
 expression must not be the blank identifier.
 </p>
 
 <pre>
 a[i] &lt;&lt;= 2
@@ skipping 75 matching lines @@
 
 <p>
 In assignments, each value must be <a href="#Assignability">assignable</a>
 to the type of the operand to which it is assigned, with the following special cases:
 </p>
 
 <ol>
 <li><p>
         If an untyped <a href="#Constants">constant</a>
         is assigned to a variable of interface type or the blank identifier,
-        the constant is <a href="#Conversions">converted</a> to type
+        the constant is first <a href="#Conversions">converted</a> to type
         <code>bool</code>, <code>rune</code>, <code>int</code>, <code>float64</code>,
         <code>complex128</code> or <code>string</code> respectively, depending on
         whether the value is a boolean, rune, integer, floating-point, complex, or
         string constant.
 </p></li>
 
 <li><p>
         <!-- Note that the result of a comparison is an untyped bool that may not be constant. -->
-        If the left-hand side is the blank identifier, any typed or non-constant
+        If a left-hand side is the blank identifier, any typed or non-constant
         value except for the predeclared identifier
         <a href="#Predeclared_identifiers"><code>nil</code></a>
         may be assigned to it.
 </p></li>
 </ol>
 
 <h3 id="If_statements">If statements</h3>
 
 <p>
 "If" statements specify the conditional execution of two branches
@@ skipping 979 matching lines @@
 string type followed by <code>...</code>. This form appends the
 bytes of the string.
 </p>
 
 <pre class="grammar">
 append(s S, x ...T) S  // T is the element type of S
 </pre>
 
 <p>
 If the capacity of <code>s</code> is not large enough to fit the additional
-values, <code>append</code> allocates a new, sufficiently large slice that fits
-both the existing slice elements and the additional values. Thus, the returned
-slice may refer to a different underlying array.
+values, <code>append</code> allocates a new, sufficiently large underlying
+array that fits both the existing slice elements and the additional values.
+Otherwise, <code>append</code> re-uses the underlying array.
 </p>
 
 <pre>
 s0 := []int{0, 0}
 s1 := append(s0, 2)                // append a single element     s1 == []int{0, 0, 2}
 s2 := append(s1, 3, 5, 7)          // append multiple elements    s2 == []int{0, 0, 2, 3, 5, 7}
 s3 := append(s2, s0...)            // append a slice              s3 == []int{0, 0, 2, 3, 5, 7, 0, 0}
 s4 := append(s3[3:6], s3[2:]...)   // append overlapping slice    s4 == []int{3, 5, 7, 2, 3, 5, 7, 0, 0}
 
 var t []interface{}
@@ skipping 655 matching lines @@
 </li>
 
 <li>For a variable <code>x</code> of array type: <code>unsafe.Alignof(x)</code> is the same as
    <code>unsafe.Alignof(x[0])</code>, but at least 1.
 </li>
 </ol>
 
 <p>
 A struct or array type has size zero if it contains no fields (or elements, respectively) that have a size greater than zero. Two distinct zero-size variables may have the same address in memory.
 </p>