code review 6862046: spec: receiver types in method expressions can be paren...

doc/go_spec.html

 <!--{
         "Title": "The Go Programming Language Specification",
-        "Subtitle": "Version of December 5, 2012",
+        "Subtitle": "Version of December 6, 2012",
         "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 2647 matching lines @@
 
 <p>
 asserts that <code>x</code> is not <code>nil</code>
 and that the value stored in <code>x</code> is of type <code>T</code>.
 The notation <code>x.(T)</code> is called a <i>type assertion</i>.
 </p>
 <p>
 More precisely, if <code>T</code> is not an interface type, <code>x.(T)</code> asserts
 that the dynamic type of <code>x</code> is <a href="#Type_identity">identical</a>
 to the type <code>T</code>.
+In this case, <code>T</code> must <a href="#Method_sets">implement</a> the (interface) type of <code>x</code>;
+otherwise the type assertion is invalid since it is not possible for <code>x</code>
+to store a value of type <code>T</code>.
 If <code>T</code> is an interface type, <code>x.(T)</code> asserts that the dynamic type
-of <code>x</code> implements the interface <code>T</code> (§<a href="#Interface_types">Interface types</a>).
+of <code>x</code> implements the interface <code>T</code>.
 </p>
 <p>
 If the type assertion holds, the value of the expression is the value
 stored in <code>x</code> and its type is <code>T</code>. If the type assertion is false,
 a <a href="#Run_time_panics">run-time panic</a> occurs.
 In other words, even though the dynamic type of <code>x</code>
 is known only at run time, the type of <code>x.(T)</code> is
 known to be <code>T</code> in a correct program.
 </p>
-<p>
-If a type assertion is used in an assignment or initialization of the form
+
+<pre>
+var x interface{} = 7  // x has dynamic type int and value 7
+i := x.(int)           // i has type int and value 7
+
+type I interface { m() }
+var y I
+s := y.(string)        // illegal: string does not implement I (missing method m)
+r := y.(io.Reader)     // r has type io.Reader and y must implement both I and io.Reader
+</pre>
+
+<p>
+If a type assertion is used in an <a href="#Assignments">assignment</a> or initialization of the form
 </p>
 
 <pre>
 v, ok = x.(T)
 v, ok := x.(T)
 var v, ok = x.(T)
 </pre>
 
 <p>
 the result of the assertion is a pair of values with types <code>(T, bool)</code>.
 If the assertion holds, the expression returns the pair <code>(x.(T), true)</code>;
 otherwise, the expression returns <code>(Z, false)</code> where <code>Z</code>
 is the <a href="#The_zero_value">zero value</a> for type <code>T</code>.
 No run-time panic occurs in this case.
 The type assertion in this construct thus acts like a function call
-returning a value and a boolean indicating success.  (§<a href="#Assignments">Assignments</a>)
+returning a value and a boolean indicating success.
 </p>
 
 
 <h3 id="Calls">Calls</h3>
 
 <p>
 Given an expression <code>f</code> of function type
 <code>F</code>,
 </p>
 
@@ skipping 628 matching lines @@
 </pre>
 
 <p>
 That function may be called normally with an explicit receiver, so
 these five invocations are equivalent:
 </p>
 
 <pre>
 t.Mv(7)
 T.Mv(t, 7)
-(T).Mv(t, t)            // receiver types in method expressions may be parenthesized

[iant, 2012/12/05 23:50:29]

I think I would omit the comment on this line.

+(T).Mv(t, t)

[quarnster, 2012/12/06 20:05:00]

Shouldn't this be "(T).Mv(t, 7)"?

[gri, 2012/12/06 20:11:42]

good catch - will fix in the next spec CL

 f1 := T.Mv; f1(t, 7)
 f2 := (T).Mv; f2(t, 7)
 </pre>
 
 <p>
 Similarly, the expression
 </p>
 
 <pre>
 (*T).Mp
@@ skipping 795 matching lines @@
 case x == 4: f3()
 }
 </pre>
 
 <h4 id="Type_switches">Type switches</h4>
 
 <p>
 A type switch compares types rather than values. It is otherwise similar
 to an expression switch. It is marked by a special switch expression that
 has the form of a <a href="#Type_assertions">type assertion</a>
-using the reserved word <code>type</code> rather than an actual type.
-Cases then match literal types against the dynamic type of the expression
-in the type assertion.
+using the reserved word <code>type</code> rather than an actual type:
+</p>
+
+<pre>
+switch x.(type) {
+// cases
+}
+</pre>
+
+<p>
+Cases then match actual types <code>T</code> against the dynamic type of the
+expression <code>x</code>. As with type assertions, <code>x</code> must be of
+<a href="#Interface_types">interface type</a>, and each non-interface type
+<code>T</code> listed in a case must implement the type of <code>x</code>.
 </p>
 
 <pre class="ebnf">
 TypeSwitchStmt  = "switch" [ SimpleStmt ";" ] TypeSwitchGuard "{" { TypeCaseClause } "}" .
 TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" .
 TypeCaseClause  = TypeSwitchCase ":" { Statement ";" } .
 TypeSwitchCase  = "case" TypeList | "default" .
 TypeList        = Type { "," Type } .
 </pre>
 
@@ skipping 15 matching lines @@
 </p>
 
 <p>
 Given an expression <code>x</code> of type <code>interface{}</code>,
 the following type switch:
 </p>
 
 <pre>
 switch i := x.(type) {
 case nil:
-        printString("x is nil")
+        printString("x is nil")                // type of i is type of x (interface{})
 case int:
-        printInt(i)  // i is an int
+        printInt(i)                            // type of i is int
 case float64:
-        printFloat64(i)  // i is a float64
+        printFloat64(i)                        // type of i is float64
 case func(int) float64:
-        printFunction(i)  // i is a function
+        printFunction(i)                       // type of i is func(int) float64
 case bool, string:
-        printString("type is bool or string")  // i is an interface{}
+        printString("type is bool or string")  // type of i is type of x (interface{})
 default:
-        printString("don't know the type")
+        printString("don't know the type")     // type of i is type of x (interface{})
 }
 </pre>
 
 <p>
 could be rewritten:
 </p>
 
 <pre>
 v := x  // x is evaluated exactly once
 if v == nil {
+        i := v                                 // type of i is type of x (interface{})
         printString("x is nil")
 } else if i, isInt := v.(int); isInt {
-        printInt(i)  // i is an int
+        printInt(i)                            // type of i is int
 } else if i, isFloat64 := v.(float64); isFloat64 {
-        printFloat64(i)  // i is a float64
+        printFloat64(i)                        // type of i is float64
 } else if i, isFunc := v.(func(int) float64); isFunc {
-        printFunction(i)  // i is a function
+        printFunction(i)                       // type of i is func(int) float64
 } else {
-        i1, isBool := v.(bool)
-        i2, isString := v.(string)
+        _, isBool := v.(bool)
+        _, isString := v.(string)
         if isBool || isString {
-                i := v
-                printString("type is bool or string")  // i is an interface{}
+                i := v                         // type of i is type of x (interface{})
+                printString("type is bool or string")
         } else {
-                i := v
-                printString("don't know the type")  // i is an interface{}
+                i := v                         // type of i is type of x (interface{})
+                printString("don't know the type")
         }
 }
 </pre>
 
 <p>
 The type switch guard may be preceded by a simple statement, which
 executes before the guard is evaluated.
 </p>
 
 <p>
@@ skipping 247 matching lines @@
 statement, the channel expressions are evaluated in top-to-bottom order, along with
 any expressions that appear on the right hand side of send statements.
 A channel may be <code>nil</code>,
 which is equivalent to that case not
 being present in the select statement
 except, if a send, its expression is still evaluated.
 If any of the resulting operations can proceed, one of those is
 chosen and the corresponding communication and statements are
 evaluated.  Otherwise, if there is a default case, that executes;
 if there is no default case, the statement blocks until one of the communications can
-complete.
+complete. There can be at most one default case and it may appear anywhere in the
+"select" statement.
 If there are no cases with non-<code>nil</code> channels,
 the statement blocks forever.
 Even if the statement blocks,
 the channel and send expressions are evaluated only once,
 upon entering the select statement.
 </p>
 <p>
 Since all the channels and send expressions are evaluated, any side
 effects in that evaluation will occur for all the communications
 in the "select" statement.
@@ skipping 1118 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>