tutorial: update discussion of variadic functions

R=rsc
CC=golang-dev
https://golang.org/cl/1677042

diff --git a/doc/go_tutorial.html b/doc/go_tutorial.html
index 40fef306935df28e1611420692f268adfb9349d6..7eb09b5b4b60880190d20c3049cf66170d24d43b 100644 (file)
--- a/doc/go_tutorial.html
+++ b/doc/go_tutorial.html
@@ -938,14 +938,19 @@ implements <code>Printf</code>, <code>Fprintf</code>, and so on.
 Within the <code>fmt</code> package, <code>Printf</code> is declared with this signature:
 <p>
 <pre>
-    Printf(format string, v ...) (n int, errno os.Error)
-</pre>
-<p>
-That <code>...</code> represents the variadic argument list that in C would
-be handled using the <code>stdarg.h</code> macros but in Go is passed using
-an empty interface variable (<code>interface {}</code>) and then unpacked
-using the reflection library.  It's off topic here but the use of
-reflection helps explain some of the nice properties of Go's <code>Printf</code>,
+    Printf(format string, v ...interface{}) (n int, errno os.Error)
+</pre>
+<p>
+The token <code>...</code> introduces a variable-length argument list that in C would
+be handled using the <code>stdarg.h</code> macros.
+In Go, variadic functions are passed a slice of the arguments of the
+specified type.  In <code>Printf</code>'s case, the declaration says <code>...interface{}</code>
+so the actual type is a slice of empty interface values, <code>[]interface{}</code>.
+<code>Printf</code> can examine the arguments by iterating over the slice
+and, for each element, using a type switch or the reflection library
+to interpret the value.
+It's off topic here but such run-time type analysis
+helps explain some of the nice properties of Go's <code>Printf</code>,
 due to the ability of <code>Printf</code> to discover the type of its arguments
 dynamically.
 <p>

diff --git a/doc/go_tutorial.txt b/doc/go_tutorial.txt
index 76dba34efd498de812e983a1ec3d839eba1fd40a..6ab6094c0297eb99aa09bb8a05581e8ff5701c5a 100644 (file)
--- a/doc/go_tutorial.txt
+++ b/doc/go_tutorial.txt
@@ -622,13 +622,18 @@ We've seen simple uses of the package "fmt", which
 implements "Printf", "Fprintf", and so on.
 Within the "fmt" package, "Printf" is declared with this signature:
 
-       Printf(format string, v ...) (n int, errno os.Error)
-
-That "..." represents the variadic argument list that in C would
-be handled using the "stdarg.h" macros but in Go is passed using
-an empty interface variable ("interface {}") and then unpacked
-using the reflection library.  It's off topic here but the use of
-reflection helps explain some of the nice properties of Go's "Printf",
+       Printf(format string, v ...interface{}) (n int, errno os.Error)
+
+The token "..." introduces a variable-length argument list that in C would
+be handled using the "stdarg.h" macros.
+In Go, variadic functions are passed a slice of the arguments of the
+specified type.  In "Printf"'s case, the declaration says "...interface{}"
+so the actual type is a slice of empty interface values, "[]interface{}".
+"Printf" can examine the arguments by iterating over the slice
+and, for each element, using a type switch or the reflection library
+to interpret the value.
+It's off topic here but such run-time type analysis
+helps explain some of the nice properties of Go's "Printf",
 due to the ability of "Printf" to discover the type of its arguments
 dynamically.