Round of fixes for the new text-template example

Making it a bit cleaner and easier to understand

examples/text-templates/text-templates.go

@@ -1,38 +1,36 @@
-// Go offers built-in support for creating
+// Go offers built-in support for creating dynamic content or showing customized
-// dynamic content or showing customized output to the user called Template.
+// output to the user with the `text/template` package. A sibling package
+// named `html/template` provides the same API but has additional security
+// features and should be used for generating HTML.
 
 package main
 
-// Go has two template packages. one is "text/template" for
-// regular text manipulation, and another one is "html/template"
-// which has the same API as "text/template" but has additional security features.
-// It should be used when generating HTML.
 import (
-	"log"
 	"os"
 	"text/template"
 )
 
 func main() {
 
-	// New creates a template with a specific name and returns a pointer to it.
+	// We can create a new template and parse its body from
+	// a string.
+	// Templates are a mix of static text and "actions" enclosed in
+	// `{{...}}` that are used to dynamically insert content.
 	t1 := template.New("t1")
-
-	// Parse parses its parameter as template body.
-	// We use {{.}} to access the value passed to the template when it's getting executed.
 	t1, err := t1.Parse("Value is {{.}}\n")
 	if err != nil {
-		log.Fatal(err)
+		panic(err)
 	}
 
-	// If we want to ignore the errors we can use Must function.
+	// Alternatively, we can use the `template.Must` function to
-	// It will panic if an error occurs when parsing the template.
+	// panic in case `Parse` returns an error. This is especially
-	t1 = template.Must(t1.Parse("Value is {{.}}\n"))
+	// useful for templates initialized in the global scope.
+	t1 = template.Must(t1.Parse("Value: {{.}}\n"))
 
-	// Execute applies parsed template to the data we pass to it and writes the output to the io.Writer.
+	// By "executing" the template we generate its text with
-	t1.Execute(os.Stdout, t1.Name())
+	// specific values for its actions. The `{{.}}` action is
+	// replaced by the value passed as a parameter to `Execute`.
 	t1.Execute(os.Stdout, "some text")
-	t1.Execute(os.Stdout, true)
 	t1.Execute(os.Stdout, 5)
 	t1.Execute(os.Stdout, []string{
 		"Go",
@@ -40,61 +38,41 @@ func main() {
 		"C++",
 		"C#",
 	})
-	t1.Execute(os.Stdout, struct{ name string }{
-		name: "Jane Doe",
-	})
 
-	// If the data is a struct we can use the {{.FieldName}} action to access its fields.
+	// Helper function we'll use below.
-	// The fields should be exported to be accessible when template is executing.
+	Create := func(name, t string) *template.Template {
-	t2, _ := template.
+		return template.Must(template.New(name).Parse(t))
-		New("t2").
+	}
-		Parse("Fullname: {{.Fullname}}\n")
+
+	// If the data is a struct we can use the `{{.FieldName}}` action to access
+	// its fields. The fields should be exported to be accessible when a
+	// template is executing.
+	t2 := Create("t2", "Name: {{.Name}}\n")
 
 	t2.Execute(os.Stdout, struct {
-		Fullname string
+		Name string
-	}{
+	}{"Jane Doe"})
-		Fullname: "Jane Doe",
-	})
 
-	// The same applies to maps; with maps there is no restriction on the case of key names.
+	// The same applies to maps; with maps there is no restriction on the
+	// case of key names.
 	t2.Execute(os.Stdout, map[string]string{
-		"Fullname": "Mickey Mouse",
+		"Name": "Mickey Mouse",
 	})
 
-	// You can use if control structure to show data conditionally.
+	// if/else provide conditional execution for templates. A value is considered
-	// The data between if block will be shown if the field is truthy.
+	// false if it's the default value of a type, such as 0, an empty string,
-	// Means it is not false  boolean, empty string, nil or zero length slice, nil map/pointer.
+	// nil pointer, etc.
-	t3, _ := template.
+	// This sample demonstrates another
-		New("t3").
+	// feature of templates: using `-` in actions to trim whitespace.
-		Parse(`{{if .Field1}}
+	t3 := Create("t3",
-					If block => {{.Field1}}
+		"{{if . -}} yes {{else -}} no {{end}}\n")
-				{{ else if .Field2}}
+	t3.Execute(os.Stdout, "not empty")
-					Else if block => {{.Field2}}
+	t3.Execute(os.Stdout, "")
-				{{ else }}
-					Else block
-				{{ end }}`)
 
-	s := struct {
+	// range blocks let us loop through slices, arrays, maps or channels. Inside
-		Field1 string
+	// the range block `{{.}}` is set to the current item of the iteration.
-		Field2 []string
+	t4 := Create("t4",
-	}{}
+		"Range: {{range .}}{{.}} {{end}}\n")
-
-	s.Field1 = ""
-	s.Field2 = []string{}
-	t3.Execute(os.Stdout, s)
-
-	s.Field1 = "Some text"
-	s.Field2 = nil
-	t3.Execute(os.Stdout, s)
-
-	// Using a range action you can loop through a slice.
-	// Each time the range block is getting executed dot will be set
-	// to current item of slice.
-	t4, _ := template.
-		New("t4").
-		Parse(`Range: {{ range . }}
-						{{.}}
-					  {{ end }}`)
 	t4.Execute(os.Stdout,
 		[]string{
 			"Go",
@@ -102,14 +80,4 @@ func main() {
 			"C++",
 			"C#",
 		})
-
-	// You can assign and reassign a value to a variable in templates.
-	t5, _ := template.
-		New("t5").
-		Parse(`Variables: 
-					{{ $language := "go" }}
-						{{ $language }}
-					{{ $language = "C" }}
-						{{ $language }}`)
-	t5.Execute(os.Stdout, nil)
 }

examples/text-templates/text-templates.hash

@@ -1,2 +1,2 @@
-69a28314f7ebd877b184b35a8166e2fcaab56754
+c29676a83f4832a77b7a9e300d3fb5fe315de7b8
--mRr-NuSB6f
+pDwkw1iMACF

examples/text-templates/text-templates.sh

@@ -1,24 +1,9 @@
 $ go run templates.go 
-Value is t1
+Value: some text
-Value is some text
+Value: 5
-Value is true
+Value: [Go Rust C++ C#]
-Value is 5
+Name: Jane Doe
-Value is [Go Rust C++ C#]
+Name: Mickey Mouse
-Value is {Jane Doe}
+yes 
-Fullname: Jane Doe
+no 
-Fullname: Mickey Mouse
+Range: Go Rust C++ C# 
-
-        Else block
-
-        Else if block => Some text
-Range: 
-        Go
-
-        Rust
-
-        C++
-
-        C#
-Variables: 
-go
-C

public/text-templates

@@ -27,8 +27,10 @@
         
         <tr>
           <td class="docs">
-            <p>Go offers built-in support for creating
+            <p>Go offers built-in support for creating dynamic content or showing customized
-dynamic content or showing customized output to the user called Template.</p>
+output to the user with the <code>text/template</code> package. A sibling package
+named <code>html/template</code> provides the same API but has additional security
+features and should be used for generating HTML.</p>
 
           </td>
           <td class="code empty leading">
@@ -42,7 +44,7 @@ dynamic content or showing customized output to the user called Template.</p>
             
           </td>
           <td class="code leading">
-            <a href="http://play.golang.org/p/-mRr-NuSB6f"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
+            <a href="http://play.golang.org/p/pDwkw1iMACF"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
           <pre class="chroma"><span class="kn">package</span> <span class="nx">main</span>
 </pre>
           </td>
@@ -50,17 +52,11 @@ dynamic content or showing customized output to the user called Template.</p>
         
         <tr>
           <td class="docs">
-            <p>Go has two template packages. one is &ldquo;text/template&rdquo; for
+            
-regular text manipulation, and another one is &ldquo;html/template&rdquo;
-which has the same API as &ldquo;text/template&rdquo; but has additional security features.
-It should be used when generating HTML.</p>
-
           </td>
           <td class="code leading">
             
-          <pre class="chroma">
+          <pre class="chroma"><span class="kn">import</span> <span class="p">(</span>
-<span class="kn">import</span> <span class="p">(</span>
-    <span class="s">&#34;log&#34;</span>
     <span class="s">&#34;os&#34;</span>
     <span class="s">&#34;text/template&#34;</span>
 <span class="p">)</span>
@@ -81,29 +77,19 @@ It should be used when generating HTML.</p>
         
         <tr>
           <td class="docs">
-            <p>New creates a template with a specific name and returns a pointer to it.</p>
+            <p>We can create a new template and parse its body from
+a string.
+Templates are a mix of static text and &ldquo;actions&rdquo; enclosed in
+<code>{{...}}</code> that are used to dynamically insert content.</p>
 
           </td>
           <td class="code leading">
             
           <pre class="chroma">
     <span class="nx">t1</span> <span class="o">:=</span> <span class="nx">template</span><span class="p">.</span><span class="nf">New</span><span class="p">(</span><span class="s">&#34;t1&#34;</span><span class="p">)</span>
-</pre>
-          </td>
-        </tr>
-        
-        <tr>
-          <td class="docs">
-            <p>Parse parses its parameter as template body.
-We use {{.}} to access the value passed to the template when it&rsquo;s getting executed.</p>
-
-          </td>
-          <td class="code leading">
-            
-          <pre class="chroma">
     <span class="nx">t1</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">t1</span><span class="p">.</span><span class="nf">Parse</span><span class="p">(</span><span class="s">&#34;Value is {{.}}\n&#34;</span><span class="p">)</span>
     <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
-        <span class="nx">log</span><span class="p">.</span><span class="nf">Fatal</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+        <span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
     <span class="p">}</span>
 </pre>
           </td>
@@ -111,29 +97,30 @@ We use {{.}} to access the value passed to the template when it&rsquo;s getting
         
         <tr>
           <td class="docs">
-            <p>If we want to ignore the errors we can use Must function.
+            <p>Alternatively, we can use the <code>template.Must</code> function to
-It will panic if an error occurs when parsing the template.</p>
+panic in case <code>Parse</code> returns an error. This is especially
+useful for templates initialized in the global scope.</p>
 
           </td>
           <td class="code leading">
             
           <pre class="chroma">
-    <span class="nx">t1</span> <span class="p">=</span> <span class="nx">template</span><span class="p">.</span><span class="nf">Must</span><span class="p">(</span><span class="nx">t1</span><span class="p">.</span><span class="nf">Parse</span><span class="p">(</span><span class="s">&#34;Value is {{.}}\n&#34;</span><span class="p">))</span>
+    <span class="nx">t1</span> <span class="p">=</span> <span class="nx">template</span><span class="p">.</span><span class="nf">Must</span><span class="p">(</span><span class="nx">t1</span><span class="p">.</span><span class="nf">Parse</span><span class="p">(</span><span class="s">&#34;Value: {{.}}\n&#34;</span><span class="p">))</span>
 </pre>
           </td>
         </tr>
         
         <tr>
           <td class="docs">
-            <p>Execute applies parsed template to the data we pass to it and writes the output to the io.Writer.</p>
+            <p>By &ldquo;executing&rdquo; the template we generate its text with
+specific values for its actions. The <code>{{.}}</code> action is
+replaced by the value passed as a parameter to <code>Execute</code>.</p>
 
           </td>
           <td class="code leading">
             
           <pre class="chroma">
-    <span class="nx">t1</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="nx">t1</span><span class="p">.</span><span class="nf">Name</span><span class="p">())</span>
     <span class="nx">t1</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="s">&#34;some text&#34;</span><span class="p">)</span>
-    <span class="nx">t1</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="kc">true</span><span class="p">)</span>
     <span class="nx">t1</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
     <span class="nx">t1</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{</span>
         <span class="s">&#34;Go&#34;</span><span class="p">,</span>
@@ -141,25 +128,36 @@ It will panic if an error occurs when parsing the template.</p>
         <span class="s">&#34;C++&#34;</span><span class="p">,</span>
         <span class="s">&#34;C#&#34;</span><span class="p">,</span>
     <span class="p">})</span>
-    <span class="nx">t1</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="kd">struct</span><span class="p">{</span> <span class="nx">name</span> <span class="kt">string</span> <span class="p">}{</span>
-        <span class="nx">name</span><span class="p">:</span> <span class="s">&#34;Jane Doe&#34;</span><span class="p">,</span>
-    <span class="p">})</span>
 </pre>
           </td>
         </tr>
         
         <tr>
           <td class="docs">
-            <p>If the data is a struct we can use the {{.FieldName}} action to access its fields.
+            <p>Helper function we&rsquo;ll use below.</p>
-The fields should be exported to be accessible when template is executing.</p>
 
           </td>
           <td class="code leading">
             
           <pre class="chroma">
-    <span class="nx">t2</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">template</span><span class="p">.</span>
+    <span class="nx">Create</span> <span class="o">:=</span> <span class="kd">func</span><span class="p">(</span><span class="nx">name</span><span class="p">,</span> <span class="nx">t</span> <span class="kt">string</span><span class="p">)</span> <span class="o">*</span><span class="nx">template</span><span class="p">.</span><span class="nx">Template</span> <span class="p">{</span>
-        <span class="nf">New</span><span class="p">(</span><span class="s">&#34;t2&#34;</span><span class="p">).</span>
+        <span class="k">return</span> <span class="nx">template</span><span class="p">.</span><span class="nf">Must</span><span class="p">(</span><span class="nx">template</span><span class="p">.</span><span class="nf">New</span><span class="p">(</span><span class="nx">name</span><span class="p">).</span><span class="nf">Parse</span><span class="p">(</span><span class="nx">t</span><span class="p">))</span>
-        <span class="nf">Parse</span><span class="p">(</span><span class="s">&#34;Fullname: {{.Fullname}}\n&#34;</span><span class="p">)</span>
+    <span class="p">}</span>
+</pre>
+          </td>
+        </tr>
+        
+        <tr>
+          <td class="docs">
+            <p>If the data is a struct we can use the <code>{{.FieldName}}</code> action to access
+its fields. The fields should be exported to be accessible when a
+template is executing.</p>
+
+          </td>
+          <td class="code leading">
+            
+          <pre class="chroma">
+    <span class="nx">t2</span> <span class="o">:=</span> <span class="nf">Create</span><span class="p">(</span><span class="s">&#34;t2&#34;</span><span class="p">,</span> <span class="s">&#34;Name: {{.Name}}\n&#34;</span><span class="p">)</span>
 </pre>
           </td>
         </tr>
@@ -171,24 +169,23 @@ The fields should be exported to be accessible when template is executing.</p>
           <td class="code leading">
             
           <pre class="chroma">    <span class="nx">t2</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="kd">struct</span> <span class="p">{</span>
-        <span class="nx">Fullname</span> <span class="kt">string</span>
+        <span class="nx">Name</span> <span class="kt">string</span>
-    <span class="p">}{</span>
+    <span class="p">}{</span><span class="s">&#34;Jane Doe&#34;</span><span class="p">})</span>
-        <span class="nx">Fullname</span><span class="p">:</span> <span class="s">&#34;Jane Doe&#34;</span><span class="p">,</span>
-    <span class="p">})</span>
 </pre>
           </td>
         </tr>
         
         <tr>
           <td class="docs">
-            <p>The same applies to maps; with maps there is no restriction on the case of key names.</p>
+            <p>The same applies to maps; with maps there is no restriction on the
+case of key names.</p>
 
           </td>
           <td class="code leading">
             
           <pre class="chroma">
     <span class="nx">t2</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="kd">map</span><span class="p">[</span><span class="kt">string</span><span class="p">]</span><span class="kt">string</span><span class="p">{</span>
-        <span class="s">&#34;Fullname&#34;</span><span class="p">:</span> <span class="s">&#34;Mickey Mouse&#34;</span><span class="p">,</span>
+        <span class="s">&#34;Name&#34;</span><span class="p">:</span> <span class="s">&#34;Mickey Mouse&#34;</span><span class="p">,</span>
     <span class="p">})</span>
 </pre>
           </td>
@@ -196,82 +193,35 @@ The fields should be exported to be accessible when template is executing.</p>
         
         <tr>
           <td class="docs">
-            <p>You can use if control structure to show data conditionally.
+            <p>if/else provide conditional execution for templates. A value is considered
-The data between if block will be shown if the field is truthy.
+false if it&rsquo;s the default value of a type, such as 0, an empty string,
-Means it is not false  boolean, empty string, nil or zero length slice, nil map/pointer.</p>
+nil pointer, etc.
+This sample demonstrates another
+feature of templates: using <code>-</code> in actions to trim whitespace.</p>
 
           </td>
           <td class="code leading">
             
           <pre class="chroma">
-    <span class="nx">t3</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">template</span><span class="p">.</span>
+    <span class="nx">t3</span> <span class="o">:=</span> <span class="nf">Create</span><span class="p">(</span><span class="s">&#34;t3&#34;</span><span class="p">,</span>
-        <span class="nf">New</span><span class="p">(</span><span class="s">&#34;t3&#34;</span><span class="p">).</span>
+        <span class="s">&#34;{{if . -}} yes {{else -}} no {{end}}\n&#34;</span><span class="p">)</span>
-        <span class="nf">Parse</span><span class="p">(</span><span class="s">`</span><span class="cp">{{</span><span class="k">if</span><span class="w"> </span><span class="na">.Field1</span><span class="cp">}}</span><span class="s">
+    <span class="nx">t3</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="s">&#34;not empty&#34;</span><span class="p">)</span>
-</span><span class="s">                    If block =&gt; </span><span class="cp">{{</span><span class="na">.Field1</span><span class="cp">}}</span><span class="s">
+    <span class="nx">t3</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="s">&#34;&#34;</span><span class="p">)</span>
-</span><span class="s">                </span><span class="cp">{{</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="na">.Field2</span><span class="cp">}}</span><span class="s">
-</span><span class="s">                    Else if block =&gt; </span><span class="cp">{{</span><span class="na">.Field2</span><span class="cp">}}</span><span class="s">
-</span><span class="s">                </span><span class="cp">{{</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="cp">}}</span><span class="s">
-</span><span class="s">                    Else block
-</span><span class="s">                </span><span class="cp">{{</span><span class="w"> </span><span class="k">end</span><span class="w"> </span><span class="cp">}}</span><span class="s">`</span><span class="p">)</span>
 </pre>
           </td>
         </tr>
         
         <tr>
           <td class="docs">
-            
+            <p>range blocks let us loop through slices, arrays, maps or channels. Inside
-          </td>
+the range block <code>{{.}}</code> is set to the current item of the iteration.</p>
-          <td class="code leading">
-            
-          <pre class="chroma">    <span class="nx">s</span> <span class="o">:=</span> <span class="kd">struct</span> <span class="p">{</span>
-        <span class="nx">Field1</span> <span class="kt">string</span>
-        <span class="nx">Field2</span> <span class="p">[]</span><span class="kt">string</span>
-    <span class="p">}{}</span>
-</pre>
-          </td>
-        </tr>
-        
-        <tr>
-          <td class="docs">
-            
-          </td>
-          <td class="code leading">
-            
-          <pre class="chroma">    <span class="nx">s</span><span class="p">.</span><span class="nx">Field1</span> <span class="p">=</span> <span class="s">&#34;&#34;</span>
-    <span class="nx">s</span><span class="p">.</span><span class="nx">Field2</span> <span class="p">=</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{}</span>
-    <span class="nx">t3</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="nx">s</span><span class="p">)</span>
-</pre>
-          </td>
-        </tr>
-        
-        <tr>
-          <td class="docs">
-            
-          </td>
-          <td class="code leading">
-            
-          <pre class="chroma">    <span class="nx">s</span><span class="p">.</span><span class="nx">Field1</span> <span class="p">=</span> <span class="s">&#34;Some text&#34;</span>
-    <span class="nx">s</span><span class="p">.</span><span class="nx">Field2</span> <span class="p">=</span> <span class="kc">nil</span>
-    <span class="nx">t3</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="nx">s</span><span class="p">)</span>
-</pre>
-          </td>
-        </tr>
-        
-        <tr>
-          <td class="docs">
-            <p>Using a range action you can loop through a slice.
-Each time the range block is getting executed dot will be set
-to current item of slice.</p>
 
           </td>
-          <td class="code leading">
+          <td class="code">
             
           <pre class="chroma">
-    <span class="nx">t4</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">template</span><span class="p">.</span>
+    <span class="nx">t4</span> <span class="o">:=</span> <span class="nf">Create</span><span class="p">(</span><span class="s">&#34;t4&#34;</span><span class="p">,</span>
-        <span class="nf">New</span><span class="p">(</span><span class="s">&#34;t4&#34;</span><span class="p">).</span>
+        <span class="s">&#34;Range: {{range .}}{{.}} {{end}}\n&#34;</span><span class="p">)</span>
-        <span class="nf">Parse</span><span class="p">(</span><span class="s">`Range: </span><span class="cp">{{</span><span class="w"> </span><span class="k">range</span><span class="w"> </span><span class="na">.</span><span class="w"> </span><span class="cp">}}</span><span class="s">
-</span><span class="s">                        </span><span class="cp">{{</span><span class="na">.</span><span class="cp">}}</span><span class="s">
-</span><span class="s">                      </span><span class="cp">{{</span><span class="w"> </span><span class="k">end</span><span class="w"> </span><span class="cp">}}</span><span class="s">`</span><span class="p">)</span>
     <span class="nx">t4</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span>
         <span class="p">[]</span><span class="kt">string</span><span class="p">{</span>
             <span class="s">&#34;Go&#34;</span><span class="p">,</span>
@@ -279,25 +229,6 @@ to current item of slice.</p>
             <span class="s">&#34;C++&#34;</span><span class="p">,</span>
             <span class="s">&#34;C#&#34;</span><span class="p">,</span>
         <span class="p">})</span>
-</pre>
-          </td>
-        </tr>
-        
-        <tr>
-          <td class="docs">
-            <p>You can assign and reassign a value to a variable in templates.</p>
-
-          </td>
-          <td class="code">
-            
-          <pre class="chroma">
-    <span class="nx">t5</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">template</span><span class="p">.</span>
-        <span class="nf">New</span><span class="p">(</span><span class="s">&#34;t5&#34;</span><span class="p">).</span>
-        <span class="nf">Parse</span><span class="p">(</span><span class="s">`Variables: </span><span class="cp">{{</span><span class="w"> </span><span class="nx">$language</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="s">&#34;go&#34;</span><span class="w"> </span><span class="cp">}}</span><span class="s">
-</span><span class="s">                    </span><span class="cp">{{</span><span class="w"> </span><span class="nx">$language</span><span class="w"> </span><span class="cp">}}</span><span class="s">
-</span><span class="s">                    </span><span class="cp">{{</span><span class="w"> </span><span class="nx">$language</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;C&#34;</span><span class="w"> </span><span class="cp">}}</span><span class="s">
-</span><span class="s">                    </span><span class="cp">{{</span><span class="w"> </span><span class="nx">$language</span><span class="w"> </span><span class="cp">}}</span><span class="s">`</span><span class="p">)</span>
-    <span class="nx">t5</span><span class="p">.</span><span class="nf">Execute</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">,</span> <span class="kc">nil</span><span class="p">)</span>
 <span class="p">}</span>
 </pre>
           </td>
@@ -307,76 +238,21 @@ to current item of slice.</p>
       
       <table>
         
-        <tr>
-          <td class="docs">
-            
-          </td>
-          <td class="code leading">
-            
-          <pre class="chroma"><span class="gp">$</span> go run templates.go 
-<span class="go">Value is my-template
-</span><span class="go">Value is some text
-</span><span class="go">Value is true
-</span><span class="go">Value is 5
-</span><span class="go">Value is [Go Rust C++ C#]
-</span><span class="go">Value is {Jane Doe}
-</span><span class="go">Fullname: Jane Doe
-</span><span class="go">Fullname: Mickey Mouse</span></pre>
-          </td>
-        </tr>
-        
-        <tr>
-          <td class="docs">
-            
-          </td>
-          <td class="code leading">
-            
-          <pre class="chroma"><span class="go">        Else block</span></pre>
-          </td>
-        </tr>
-        
-        <tr>
-          <td class="docs">
-            
-          </td>
-          <td class="code leading">
-            
-          <pre class="chroma"><span class="go">        Else if block =&gt; Some text
-</span><span class="go">Range: 
-</span><span class="go">        Go</span></pre>
-          </td>
-        </tr>
-        
-        <tr>
-          <td class="docs">
-            
-          </td>
-          <td class="code leading">
-            
-          <pre class="chroma"><span class="go">        Rust</span></pre>
-          </td>
-        </tr>
-        
-        <tr>
-          <td class="docs">
-            
-          </td>
-          <td class="code leading">
-            
-          <pre class="chroma"><span class="go">        C++</span></pre>
-          </td>
-        </tr>
-        
         <tr>
           <td class="docs">
             
           </td>
           <td class="code">
             
-          <pre class="chroma"><span class="go">        C#
+          <pre class="chroma"><span class="gp">$</span> go run templates.go 
-</span><span class="go">Variables: 
+<span class="go">Value: some text
-</span><span class="go">go
+</span><span class="go">Value: 5
-</span><span class="go">C</span></pre>
+</span><span class="go">Value: [Go Rust C++ C#]
+</span><span class="go">Name: Jane Doe
+</span><span class="go">Name: Mickey Mouse
+</span><span class="go">yes 
+</span><span class="go">no 
+</span><span class="go">Range: Go Rust C++ C# </span></pre>
           </td>
         </tr>
         
@@ -395,7 +271,7 @@ to current item of slice.</p>
     </div>
     <script>
       var codeLines = [];
-      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"log\"\u000A    \"os\"\u000A    \"text/template\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push('    t1 :\u003D template.New(\"t1\")\u000A');codeLines.push('    t1, err :\u003D t1.Parse(\"Value is {{.}}\\n\")\u000A    if err !\u003D nil {\u000A        log.Fatal(err)\u000A    }\u000A');codeLines.push('    t1 \u003D template.Must(t1.Parse(\"Value is {{.}}\\n\"))\u000A');codeLines.push('    t1.Execute(os.Stdout, t1.Name())\u000A    t1.Execute(os.Stdout, \"some text\")\u000A    t1.Execute(os.Stdout, true)\u000A    t1.Execute(os.Stdout, 5)\u000A    t1.Execute(os.Stdout, []string{\u000A        \"Go\",\u000A        \"Rust\",\u000A        \"C++\",\u000A        \"C#\",\u000A    })\u000A    t1.Execute(os.Stdout, struct{ name string }{\u000A        name: \"Jane Doe\",\u000A    })\u000A');codeLines.push('    t2, _ :\u003D template.\u000A        New(\"t2\").\u000A        Parse(\"Fullname: {{.Fullname}}\\n\")\u000A');codeLines.push('    t2.Execute(os.Stdout, struct {\u000A        Fullname string\u000A    }{\u000A        Fullname: \"Jane Doe\",\u000A    })\u000A');codeLines.push('    t2.Execute(os.Stdout, map[string]string{\u000A        \"Fullname\": \"Mickey Mouse\",\u000A    })\u000A');codeLines.push('    t3, _ :\u003D template.\u000A        New(\"t3\").\u000A        Parse(`{{if .Field1}}\u000A                    If block \u003D\u003E {{.Field1}}\u000A                {{ else if .Field2}}\u000A                    Else if block \u003D\u003E {{.Field2}}\u000A                {{ else }}\u000A                    Else block\u000A                {{ end }}`)\u000A');codeLines.push('    s :\u003D struct {\u000A        Field1 string\u000A        Field2 []string\u000A    }{}\u000A');codeLines.push('    s.Field1 \u003D \"\"\u000A    s.Field2 \u003D []string{}\u000A    t3.Execute(os.Stdout, s)\u000A');codeLines.push('    s.Field1 \u003D \"Some text\"\u000A    s.Field2 \u003D nil\u000A    t3.Execute(os.Stdout, s)\u000A');codeLines.push('    t4, _ :\u003D template.\u000A        New(\"t4\").\u000A        Parse(`Range: {{ range . }}\u000A                        {{.}}\u000A                      {{ end }}`)\u000A    t4.Execute(os.Stdout,\u000A        []string{\u000A            \"Go\",\u000A            \"Rust\",\u000A            \"C++\",\u000A            \"C#\",\u000A        })\u000A');codeLines.push('    t5, _ :\u003D template.\u000A        New(\"t5\").\u000A        Parse(`Variables: {{ $language :\u003D \"go\" }}\u000A                    {{ $language }}\u000A                    {{ $language \u003D \"C\" }}\u000A                    {{ $language }}`)\u000A    t5.Execute(os.Stdout, nil)\u000A}\u000A');codeLines.push('');codeLines.push('');codeLines.push('');codeLines.push('');codeLines.push('');codeLines.push('');
+      codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A    \"os\"\u000A    \"text/template\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push('    t1 :\u003D template.New(\"t1\")\u000A    t1, err :\u003D t1.Parse(\"Value is {{.}}\\n\")\u000A    if err !\u003D nil {\u000A        panic(err)\u000A    }\u000A');codeLines.push('    t1 \u003D template.Must(t1.Parse(\"Value: {{.}}\\n\"))\u000A');codeLines.push('    t1.Execute(os.Stdout, \"some text\")\u000A    t1.Execute(os.Stdout, 5)\u000A    t1.Execute(os.Stdout, []string{\u000A        \"Go\",\u000A        \"Rust\",\u000A        \"C++\",\u000A        \"C#\",\u000A    })\u000A');codeLines.push('    Create :\u003D func(name, t string) *template.Template {\u000A        return template.Must(template.New(name).Parse(t))\u000A    }\u000A');codeLines.push('    t2 :\u003D Create(\"t2\", \"Name: {{.Name}}\\n\")\u000A');codeLines.push('    t2.Execute(os.Stdout, struct {\u000A        Name string\u000A    }{\"Jane Doe\"})\u000A');codeLines.push('    t2.Execute(os.Stdout, map[string]string{\u000A        \"Name\": \"Mickey Mouse\",\u000A    })\u000A');codeLines.push('    t3 :\u003D Create(\"t3\",\u000A        \"{{if . -}} yes {{else -}} no {{end}}\\n\")\u000A    t3.Execute(os.Stdout, \"not empty\")\u000A    t3.Execute(os.Stdout, \"\")\u000A');codeLines.push('    t4 :\u003D Create(\"t4\",\u000A        \"Range: {{range .}}{{.}} {{end}}\\n\")\u000A    t4.Execute(os.Stdout,\u000A        []string{\u000A            \"Go\",\u000A            \"Rust\",\u000A            \"C++\",\u000A            \"C#\",\u000A        })\u000A}\u000A');codeLines.push('');
     </script>
     <script src="site.js" async></script>
   </body>