code review 5755051: doc: fix typos in laws_of_reflection article.

doc/articles/laws_of_reflection.html

 <!--{
         "Title": "The Laws of Reflection"
 }-->
 <!--
   DO NOT EDIT: created by
     tmpltohtml articles/laws_of_reflection.tmpl
 -->
 
 
 <p>
@@ skipping 338 matching lines @@
     fmt.Println(&#34;kind is uint8: &#34;, v.Kind() == reflect.Uint8) // true.
     x = uint8(v.Uint())                                       // v.Uint returns a uint64.</pre>
 
 <p>
 The second property is that the <code>Kind</code> of a reflection
 object describes the underlying type, not the static type. If a
 reflection object contains a value of a user-defined integer type,
 as in
 </p>
 
-<pre><!--{{code "progs/interface2.go" `/START f3/` `/START/`}}
+<pre><!--{{code "progs/interface2.go" `/START f3/` `/STOP/`}}
 -->    type MyInt int
     var x MyInt = 7
     v := reflect.ValueOf(x)</pre>
 
 <p>
 the <code>Kind</code> of <code>v</code> is still
 <code>reflect.Int</code>, even though the static type of
 <code>x</code> is <code>MyInt</code>, not <code>int</code>. In
 other words, the <code>Kind</code> cannot discriminate an int from
 a <code>MyInt</code> even though the <code>Type</code> can.
@@ skipping 18 matching lines @@
 
 <pre>
 // Interface returns v's value as an interface{}.
 func (v Value) Interface() interface{}
 </pre>
 
 <p>
 As a consequence we can say
 </p>
 
-<pre><!--{{code "progs/interface2.go" `/START f3b/` `/START/`}}
+<pre><!--{{code "progs/interface2.go" `/START f3b/` `/STOP/`}}
 -->    y := v.Interface().(float64) // y will have type float64.
     fmt.Println(y)</pre>
 
 <p>
 to print the <code>float64</code> value represented by the
 reflection object <code>v</code>.
 </p>
 
 <p>
 We can do even better, though. The arguments to
 <code>fmt.Println</code>, <code>fmt.Printf</code> and so on are all
 passed as empty interface values, which are then unpacked by the
 <code>fmt</code> package internally just as we have been doing in
 the previous examples. Therefore all it takes to print the contents
 of a <code>reflect.Value</code> correctly is to pass the result of
 the <code>Interface</code> method to the formatted print
 routine:
 </p>
 
-<pre><!--{{code "progs/interface2.go" `/START f3c/` `/START/`}}
+<pre><!--{{code "progs/interface2.go" `/START f3c/` `/STOP/`}}
 -->    fmt.Println(v.Interface())</pre>
 
 <p>
 (Why not <code>fmt.Println(v)</code>? Because <code>v</code> is a
 <code>reflect.Value</code>; we want the concrete value it holds.)
 Since our value is a <code>float64</code>, we can even use a
 floating-point format if we want:
 </p>
 
 <pre><!--{{code "progs/interface2.go" `/START f3d/` `/STOP/`}}
@@ skipping 82 matching lines @@
 </p>
 
 <p>
 Settability is a bit like addressability, but stricter. It's the
 property that a reflection object can modify the actual storage
 that was used to create the reflection object. Settability is
 determined by whether the reflection object holds the original
 item. When we say
 </p>
 
-<pre><!--{{code "progs/interface2.go" `/START f6/` `/START/`}}
+<pre><!--{{code "progs/interface2.go" `/START f6/` `/STOP/`}}
 -->    var x float64 = 3.4
     v := reflect.ValueOf(x)</pre>
 
 <p>
 we pass a <em>copy</em> of <code>x</code> to
 <code>reflect.ValueOf</code>, so the interface value created as the
 argument to <code>reflect.ValueOf</code> is a <em>copy</em> of
 <code>x</code>, not <code>x</code> itself. Thus, if the
 statement
 </p>
@@ skipping 38 matching lines @@
 give the reflection library a pointer to the value we want to
 modify.
 </p>
 
 <p>
 Let's do that. First we initialize <code>x</code> as usual
 and then create a reflection value that points to it, called
 <code>p</code>.
 </p>
 
-<pre><!--{{code "progs/interface2.go" `/START f7/` `/START/`}}
+<pre><!--{{code "progs/interface2.go" `/START f7/` `/STOP/`}}
 -->    var x float64 = 3.4
     p := reflect.ValueOf(&amp;x) // Note: take the address of x.
     fmt.Println(&#34;type of p:&#34;, p.Type())
     fmt.Println(&#34;settability of p:&#34;, p.CanSet())</pre>
 
 <p>
 The output so far is
 </p>
 
 <pre>
 type of p: *float64
 settability of p: false
 </pre>
 
 <p>
 The reflection object <code>p</code> isn't settable, but it's not
 <code>p</code> we want to set, it's (in effect) <code>*p</code>. To
 get to what <code>p</code> points to, we call the <code>Elem</code>
 method of <code>Value</code>, which indirects through the pointer,
 and save the result in a reflection <code>Value</code> called
 <code>v</code>:
 </p>
 
-<pre><!--{{code "progs/interface2.go" `/START f7b/` `/START/`}}
+<pre><!--{{code "progs/interface2.go" `/START f7b/` `/STOP/`}}
 -->    v := p.Elem()
     fmt.Println(&#34;settability of v:&#34;, v.CanSet())</pre>
 
 <p>
 Now <code>v</code> is a settable reflection object, as the output
 demonstrates,
 </p>
 
 <pre>
 settability of v: true
@@ skipping 42 matching lines @@
 <code>t</code>. We create the reflection object with the address of
 the struct because we'll want to modify it later. Then we set
 <code>typeOfT</code> to its type and iterate over the fields using
 straightforward method calls (see·
 <a href="http://golang.org/pkg/reflect/">package reflect</a> for details).
 Note that we extract the names of the fields from the struct type,
 but the fields themselves are regular <code>reflect.Value</code>
 objects.
 </p>
 
-<pre><!--{{code "progs/interface2.go" `/START f8/` `/START/`}}
+<pre><!--{{code "progs/interface2.go" `/START f8/` `/STOP/`}}
 -->    type T struct {
         A int
         B string
     }
     t := T{23, &#34;skidoo&#34;}
     s := reflect.ValueOf(&amp;t).Elem()
     typeOfT := s.Type()
     for i := 0; i &lt; s.NumField(); i++ {
         f := s.Field(i)
         fmt.Printf(&#34;%d: %s %s = %v\n&#34;, i,
@@ skipping 62 matching lines @@
 necessary.
 </p>
 
 <p>
 There's plenty more to reflection that we haven't covered &mdash;
 sending and receiving on channels, allocating memory, using slices
 and maps, calling methods and functions &mdash; but this post is
 long enough. We'll cover some of those topics in a later
 article.
 </p>