From 94439492077c16876c1243221923f51cb237627c Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Fri, 6 Jan 2012 09:21:43 +1100
Subject: [PATCH] doc: add Slices: usage and internals article

Originally published on the Go blog on 5 Jan 2011:
http://blog.golang.org/2011/01/go-slices-usage-and-internals.html

R=golang-dev, gri
CC=golang-dev
https://golang.org/cl/5516046
---
 doc/Makefile                                 |   1 +
 doc/articles/slice-1.png                     | Bin 0 -> 6334 bytes
 doc/articles/slice-2.png                     | Bin 0 -> 7220 bytes
 doc/articles/slice-3.png                     | Bin 0 -> 7303 bytes
 doc/articles/slice-array.png                 | Bin 0 -> 1237 bytes
 doc/articles/slice-struct.png                | Bin 0 -> 3650 bytes
 doc/articles/slices_usage_and_internals.html | 477 +++++++++++++++++++
 doc/articles/slices_usage_and_internals.tmpl | 436 +++++++++++++++++
 doc/progs/run                                |   1 +
 doc/progs/slices.go                          |  55 +++
 10 files changed, 970 insertions(+)
 create mode 100644 doc/articles/slice-1.png
 create mode 100644 doc/articles/slice-2.png
 create mode 100644 doc/articles/slice-3.png
 create mode 100644 doc/articles/slice-array.png
 create mode 100644 doc/articles/slice-struct.png
 create mode 100644 doc/articles/slices_usage_and_internals.html
 create mode 100644 doc/articles/slices_usage_and_internals.tmpl
 create mode 100644 doc/progs/slices.go

diff --git a/doc/Makefile b/doc/Makefile
index daa0a5ea2b6..9a52b257a36 100644
--- a/doc/Makefile
+++ b/doc/Makefile
@@ -11,6 +11,7 @@ GOFILES=\
 HTML=\
 	articles/defer_panic_recover.html\
 	articles/error_handling.html\
+	articles/slices_usage_and_internals.html\
 	effective_go.html\
 	go1.html\
 	go_tutorial.html\
diff --git a/doc/articles/slice-1.png b/doc/articles/slice-1.png
new file mode 100644
index 0000000000000000000000000000000000000000..ba465cf71849e590ecc4e614f423f7cc97d0d1b0
GIT binary patch
literal 6334
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

literal 0
HcmV?d00001

diff --git a/doc/articles/slice-2.png b/doc/articles/slice-2.png
new file mode 100644
index 0000000000000000000000000000000000000000..a57581e8cfcf706f8206d1d1069d976b7166816d
GIT binary patch
literal 7220
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
C@0>UQ

literal 0
HcmV?d00001

diff --git a/doc/articles/slice-3.png b/doc/articles/slice-3.png
new file mode 100644
index 0000000000000000000000000000000000000000..64ece5e877dff6d486a7c97333909c403f34a7d4
GIT binary patch
literal 7303
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

literal 0
HcmV?d00001

diff --git a/doc/articles/slice-array.png b/doc/articles/slice-array.png
new file mode 100644
index 0000000000000000000000000000000000000000..a533702cf6c8dbf40a5a3889cf2af95b7d3108cd
GIT binary patch
literal 1237
zcmeAS@N?(olHy`uVBq!ia0y~yU}6QbT{zf)q#(Q7TOh?)9OUlAu<o49OCX0W$=lt9
z;Xep2*t>i(P=vF<BeIx*fm;}a85w5HkpK#^mw5WRvfpN8W8@LcerO8PDOutgQR1AR
zo12<f!r)w#npl#WqEMb$lA+-4=^GH<$S2Ogz+&L(;uunK>+K!ijwz)w>>u90ShYGj
z>{gIccbj4(N4BfJxufDy=L*lJJk?WaF6Pz}RWBr}Z*G_%u=0S$$_3M%*=<?e7Ul&^
z3`y$Tuw!+{x-Z*am)*E2bu6s>nxyRWpEU^;W%DZMwLky=-}d*1x&J?(0r`NzM`LTn
z@2bfq;%k=8^}IECj#j|z+mm%XKY34@$h5UOa?)ncbK-9#{;QnK_Pehja^=xRmG-F;
zQRh4+ty5v%#q?_R+N1kzmsPulSC!j_&S+Y9_sZ;x7f;{ZUtRp}<(&8qGyBbN*Upi%
znE&?nwWpm|wYe@nW1cVPdH<estM$J5?`}?RG#0<5_HRGq!UbyO=jPA8+OMzg<LLc#
z<9zq<yVIA(a&upNw)5@g$twJJ>hlw`?*9L~(n;?A+u}6KY-i@P7g!k@0vH%LD5Fdg
zH6&J7`99mZ>iqg`_qJ{;HC;VLfMHhok_QV_YRwbw+j|v-a565iyR~d*T;`;o+>>f1
zq?}VZ-G6n%+U&}pp9~8u-MP|KD$PBY=dm^<wKs)NTI2nxruTK|{a}NSb*Yo|C&hRf
zO-U)A)Yp}&7A?=PqjO<G?Ic;xdw!eN``xygk&-*9(o;<B=By>*Cm9x0Iv>2G@?Pbq
zrl-H`_qP?3o<0rukX3o_*rzR@>{^1B)yFe21S}7@Fz<=OvG%X#s*>v-@7o)|C$&Gk
zM?fdQh#{kA+v}M9`X`$u_xC@zZT0?kxoG|T)xjN%3{oaRA95;xRsH+_(B*ou@Pqi!
z+rSiSA;Q4m<T&Yn-lx@dq4oDTgcq})o+`+YSEsRKCfn)Dk3IdgR2f9fMfS{i;xcJs
z%+H8ah6SEZj=Ix%msOoySoQCp%IQgGyf%4gGA`Jm%*x;(>-*i3HCgojz3fOihKwLL
zE{2B8)~1tnRX0|A&6{!Qk#2BY*@H8z?tBcb{H(g!Z@$b13Ot<^YsJH`up#Beoeh2r
z4jLJuQ>XKLb#Gsi|Nfv(<&&pp;x0|*x3@1lTC_DLkAY#~1F^D4*BAaN$Vk6eom^~|
zd-wDEKb@y}V3OM&FXeqX!(3hZ`ubD%l^0vFFf3fK;@z&~c_6bH7+RQ?B|JMLDQQz3
z=+2-ZB67FQRQvMR4`s594&IrUSs!cF`v&|y-Sq0a{QI{T6B)M10R4qCnfZjCw%?PH
z@WJWZ-ufK|tg^dp>})^Wym)8tgKbV*em?pj?>R|-|G%9ErT>=wPf_fD|IoYM3Yc`K
zM(xPG>)EGixMj{nmF`JAFS!hY3_|~UmZ?QXZJ4F!S5!Sop8LwPJ{9drGM+|J3(CsX
of9jsx*(Ccoo|6TXZ7*c}XYljbt$Nkb(gei!boFyt=akR{0Nb|;_5c6?

literal 0
HcmV?d00001

diff --git a/doc/articles/slice-struct.png b/doc/articles/slice-struct.png
new file mode 100644
index 0000000000000000000000000000000000000000..f9141fc5920ab001dbdfd66bd338e8829d411917
GIT binary patch
literal 3650
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
D%f_=P

literal 0
HcmV?d00001

diff --git a/doc/articles/slices_usage_and_internals.html b/doc/articles/slices_usage_and_internals.html
new file mode 100644
index 00000000000..66ca4a2b548
--- /dev/null
+++ b/doc/articles/slices_usage_and_internals.html
@@ -0,0 +1,477 @@
+<!-- Slices: usage and internals -->
+<!--
+  DO NOT EDIT: created by
+    tmpltohtml articles/slices_usage_and_internals.tmpl
+-->
+
+
+<p>
+Go's slice type provides a convenient and efficient means of working with
+sequences of typed data. Slices are analogous to arrays in other languages, but
+have some unusual properties. This article will look at what slices are and how
+they are used.
+</p>
+
+<p>
+<b>Arrays</b>
+</p>
+
+<p>
+The slice type is an abstraction built on top of Go's array type, and so to
+understand slices we must first understand arrays.
+</p>
+
+<p>
+An array type definition specifies a length and an element type. For example,
+the type <code>[4]int</code> represents an array of four integers. An array's
+size is fixed; its length is part of its type (<code>[4]int</code> and
+<code>[5]int</code> are distinct, incompatible types). Arrays can be indexed in
+the usual way, so the expression <code>s[n]</code> accesses the <i>n</i>th
+element:
+</p>
+
+<pre>
+var a [4]int
+a[0] = 1
+i := a[0]
+// i == 1
+</pre>
+
+<p>
+Arrays do not need to be initialized explicitly; the zero value of an array is
+a ready-to-use array whose elements are themselves zeroed:
+</p>
+
+<pre>
+// a[2] == 0, the zero value of the int type
+</pre>
+
+<p>
+The in-memory representation of <code>[4]int</code> is just four integer values laid out sequentially:
+</p>
+
+<p>
+<img src="slice-array.png">
+</p>
+
+<p>
+Go's arrays are values. An array variable denotes the entire array; it is not a
+pointer to the first array element (as would be the case in C).  This means
+that when you assign or pass around an array value you will make a copy of its
+contents. (To avoid the copy you could pass a <i>pointer</i> to the array, but
+then that's a pointer to an array, not an array.) One way to think about arrays
+is as a sort of struct but with indexed rather than named fields: a fixed-size
+composite value.
+</p>
+
+<p>
+An array literal can be specified like so:
+</p>
+
+<pre>
+b := [2]string{"Penn", "Teller"}
+</pre>
+
+<p>
+Or, you can have the compiler count the array elements for you:
+</p>
+
+<pre>
+b := [...]string{"Penn", "Teller"}
+</pre>
+
+<p>
+In both cases, the type of <code>b</code> is <code>[2]string</code>.
+</p>
+
+<p>
+<b>Slices</b>
+</p>
+
+<p>
+Arrays have their place, but they're a bit inflexible, so you don't see them
+too often in Go code. Slices, though, are everywhere. They build on arrays to
+provide great power and convenience.
+</p>
+
+<p>
+The type specification for a slice is <code>[]T</code>, where <code>T</code> is
+the type of the elements of the slice. Unlike an array type, a slice type has
+no specified length.
+</p>
+
+<p>
+A slice literal is declared just like an array literal, except you leave out
+the element count:
+</p>
+
+<pre>
+letters := []string{"a", "b", "c", "d"}
+</pre>
+
+<p>
+A slice can be created with the built-in function called <code>make</code>,
+which has the signature,
+</p>
+
+<pre>
+func make([]T, len, cap) []T
+</pre>
+
+<p>
+where T stands for the element type of the slice to be created. The
+<code>make</code> function takes a type, a length, and an optional capacity.
+When called, <code>make</code> allocates an array and returns a slice that
+refers to that array.
+</p>
+
+<pre>
+var s []byte
+s = make([]byte, 5, 5)
+// s == []byte{0, 0, 0, 0, 0}
+</pre>
+
+<p>
+When the capacity argument is omitted, it defaults to the specified length.
+Here's a more succinct version of the same code:
+</p>
+
+<pre>
+s := make([]byte, 5)
+</pre>
+
+<p>
+The length and capacity of a slice can be inspected using the built-in
+<code>len</code> and <code>cap</code> functions.
+</p>
+
+<pre>
+len(s) == 5
+cap(s) == 5
+</pre>
+
+<p>
+The next two sections discuss the relationship between length and capacity.
+</p>
+
+<p>
+The zero value of a slice is <code>nil</code>. The <code>len</code> and
+<code>cap</code> functions will both return 0 for a nil slice.
+</p>
+
+<p>
+A slice can also be formed by "slicing" an existing slice or array. Slicing is
+done by specifying a half-open range with two indices separated by a colon. For
+example, the expression <code>b[1:4]</code> creates a slice including elements
+1 through 3 of <code>b</code> (the indices of the resulting slice will be 0
+through 2).
+</p>
+
+<pre>
+b := []byte{'g', 'o', 'l', 'a', 'n', 'g'}
+// b[1:4] == []byte{'o', 'l', 'a'}, sharing the same storage as b
+</pre>
+
+<p>
+The start and end indices of a slice expression are optional; they default to zero and the slice's length respectively:
+</p>
+
+<pre>
+// b[:2] == []byte{'g', 'o'}
+// b[2:] == []byte{'l', 'a', 'n', 'g'}
+// b[:] == b
+</pre>
+
+<p>
+This is also the syntax to create a slice given an array:
+</p>
+
+<pre>
+x := [3]string{"Лайка", "Белка", "Стрелка"}
+s := x[:] // a slice referencing the storage of x
+</pre>
+
+<p>
+<b>Slice internals</b>
+</p>
+
+<p>
+A slice is a descriptor of an array segment. It consists of a pointer to the
+array, the length of the segment, and its capacity (the maximum length of the
+segment).
+</p>
+
+<p>
+<img src="slice-struct.png">
+</p>
+
+<p>
+Our variable <code>s</code>, created earlier by <code>make([]byte, 5)</code>,
+is structured like this:
+</p>
+
+<p>
+<img src="slice-1.png">
+</p>
+
+<p>
+The length is the number of elements referred to by the slice. The capacity is
+the number of elements in the underlying array (beginning at the element
+referred to by the slice pointer). The distinction between length and capacity
+will be made clear as we walk through the next few examples.
+</p>
+
+<p>
+As we slice <code>s</code>, observe the changes in the slice data structure and
+their relation to the underlying array:
+</p>
+
+<pre>
+s = s[2:4]
+</pre>
+
+<p>
+<img src="slice-2.png">
+</p>
+
+<p>
+Slicing does not copy the slice's data. It creates a new slice value that
+points to the original array. This makes slice operations as efficient as
+manipulating array indices. Therefore, modifying the <i>elements</i> (not the
+slice itself) of a re-slice modifies the elements of the original slice:
+</p>
+
+<pre>
+d := []byte{'r', 'o', 'a', 'd'}
+e := d[2:] 
+// e == []byte{'a', 'd'}
+e[1] == 'm'
+// e == []byte{'a', 'm'}
+// d == []byte{'r', 'o', 'a', 'm'}
+</pre>
+
+<p>
+Earlier we sliced <code>s</code> to a length shorter than its capacity. We can
+grow s to its capacity by slicing it again:
+</p>
+
+<pre>
+s = s[:cap(s)]
+</pre>
+
+<p>
+<img src="slice-3.png">
+</p>
+
+<p>
+A slice cannot be grown beyond its capacity. Attempting to do so will cause a
+runtime panic, just as when indexing outside the bounds of a slice or array.
+Similarly, slices cannot be re-sliced below zero to access earlier elements in
+the array.
+</p>
+
+<p>
+<b>Growing slices (the copy and append functions)</b>
+</p>
+
+<p>
+To increase the capacity of a slice one must create a new, larger slice and
+copy the contents of the original slice into it. This technique is how dynamic
+array implementations from other languages work behind the scenes. The next
+example doubles the capacity of <code>s</code> by making a new slice,
+<code>t</code>, copying the contents of <code>s</code> into <code>t</code>, and
+then assigning the slice value <code>t</code> to <code>s</code>:
+</p>
+
+<pre>
+t := make([]byte, len(s), (cap(s)+1)*2) // +1 in case cap(s) == 0
+for i := range s {
+        t[i] = s[i]
+}
+s = t
+</pre>
+
+<p>
+The looping piece of this common operation is made easier by the built-in copy
+function. As the name suggests, copy copies data from a source slice to a
+destination slice. It returns the number of elements copied.
+</p>
+
+<pre>
+func copy(dst, src []T) int
+</pre>
+
+<p>
+The <code>copy</code> function supports copying between slices of different
+lengths (it will copy only up to the smaller number of elements). In addition,
+<code>copy</code> can handle source and destination slices that share the same
+underlying array, handling overlapping slices correctly.
+</p>
+
+<p>
+Using <code>copy</code>, we can simplify the code snippet above:
+</p>
+
+<pre>
+t := make([]byte, len(s), (cap(s)+1)*2)
+copy(t, s)
+s = t
+</pre>
+
+<p>
+A common operation is to append data to the end of a slice. This function
+appends byte elements to a slice of bytes, growing the slice if necessary, and
+returns the updated slice value:
+</p>
+
+<pre><!--{{code "progs/slices.go" `/AppendByte/` `/STOP/`}}
+-->func AppendByte(slice []byte, data ...byte) []byte {
+    m := len(slice)
+    n := m + len(data)
+    if n &gt; cap(slice) { // if necessary, reallocate
+        // allocate double what&#39;s needed, for future growth.
+        newSlice := make([]byte, (n+1)*2)
+        copy(newSlice, slice)
+        slice = newSlice
+    }
+    slice = slice[0:n]
+    copy(slice[m:n], data)
+    return slice
+}</pre>
+
+<p>
+One could use <code>AppendByte</code> like this:
+</p>
+
+<pre>
+p := []byte{2, 3, 5}
+p = AppendByte(p, 7, 11, 13)
+// p == []byte{2, 3, 5, 7, 11, 13}
+</pre>
+
+<p>
+Functions like <code>AppendByte</code> are useful because they offer complete
+control over the way the slice is grown. Depending on the characteristics of
+the program, it may be desirable to allocate in smaller or larger chunks, or to
+put a ceiling on the size of a reallocation.
+</p>
+
+<p>
+But most programs don't need complete control, so Go provides a built-in
+<code>append</code> function that's good for most purposes; it has the
+signature
+</p>
+
+<pre>
+func append(s []T, x ...T) []T 
+</pre>
+
+<p>
+The <code>append</code> function appends the elements <code>x</code> to the end
+of the slice <code>s</code>, and grows the slice if a greater capacity is
+needed.
+</p>
+
+<pre>
+a := make([]int, 1)
+// a == []int{0}
+a = append(a, 1, 2, 3)
+// a == []int{0, 1, 2, 3}
+</pre>
+
+<p>
+To append one slice to another, use <code>...</code> to expand the second
+argument to a list of arguments.
+</p>
+
+<pre>
+a := []string{"John", "Paul"}
+b := []string{"George", "Ringo", "Pete"}
+a = append(a, b...) // equivalent to "append(a, b[0], b[1], b[2])"
+// a == []string{"John", "Paul", "George", "Ringo", "Pete"}
+</pre>
+
+<p>
+Since the zero value of a slice (<code>nil</code>) acts like a zero-length
+slice, you can declare a slice variable and then append to it in a loop:
+</p>
+
+<pre><!--{{code "progs/slices.go" `/Filter/` `/STOP/`}}
+-->// Filter returns a new slice holding only
+// the elements of s that satisfy f()
+func Filter(s []int, fn func(int) bool) []int {
+    var p []int // == nil
+    for _, i := range s {
+        if fn(i) {
+            p = append(p, i)
+        }
+    }
+    return p
+}</pre>
+
+<p>
+<b>A possible "gotcha"</b>
+</p>
+
+<p>
+As mentioned earlier, re-slicing a slice doesn't make a copy of the underlying
+array. The full array will be kept in memory until it is no longer referenced.
+Occasionally this can cause the program to hold all the data in memory when
+only a small piece of it is needed.
+</p>
+
+<p>
+For example, this <code>FindDigits</code> function loads a file into memory and
+searches it for the first group of consecutive numeric digits, returning them
+as a new slice.
+</p>
+
+<pre><!--{{code "progs/slices.go" `/digit/` `/STOP/`}}
+-->var digitRegexp = regexp.MustCompile(&#34;[0-9]+&#34;)
+
+func FindDigits(filename string) []byte {
+    b, _ := ioutil.ReadFile(filename)
+    return digitRegexp.Find(b)
+}</pre>
+
+<p>
+This code behaves as advertised, but the returned <code>[]byte</code> points
+into an array containing the entire file. Since the slice references the
+original array, as long as the slice is kept around the garbage collector can't
+release the array; the few useful bytes of the file keep the entire contents in
+memory.
+</p>
+
+<p>
+To fix this problem one can copy the interesting data to a new slice before
+returning it:
+</p>
+
+<pre><!--{{code "progs/slices.go" `/CopyDigits/` `/STOP/`}}
+-->func CopyDigits(filename string) []byte {
+    b, _ := ioutil.ReadFile(filename)
+    b = digitRegexp.Find(b)
+    c := make([]byte, len(b))
+    copy(c, b)
+    return c
+}</pre>
+
+<p>
+A more concise version of this function could be constructed by using
+<code>append</code>. This is left as an exercise for the reader.
+</p>
+
+<p>
+<b>Further Reading</b>
+</p>
+
+<p>
+<a href="/doc/effective_go.html">Effective Go</a> contains an
+in-depth treatment of <a href="/doc/effective_go.html#slices">slices</a>
+and <a href="/doc/effective_go.html#arrays">arrays</a>, 
+and the Go <a href="/doc/go_spec.html">language specification</a>
+defines <a href="/doc/go_spec.html#Slice_types">slices</a> and their
+<a href="/doc/go_spec.html#Length_and_capacity">associated</a>
+<a href="/doc/go_spec.html#Making_slices_maps_and_channels">helper</a>
+<a href="/doc/go_spec.html#Appending_and_copying_slices">functions</a>.
+</p>
diff --git a/doc/articles/slices_usage_and_internals.tmpl b/doc/articles/slices_usage_and_internals.tmpl
new file mode 100644
index 00000000000..94929818b01
--- /dev/null
+++ b/doc/articles/slices_usage_and_internals.tmpl
@@ -0,0 +1,436 @@
+<!-- Slices: usage and internals -->
+{{donotedit}}
+
+<p>
+Go's slice type provides a convenient and efficient means of working with
+sequences of typed data. Slices are analogous to arrays in other languages, but
+have some unusual properties. This article will look at what slices are and how
+they are used.
+</p>
+
+<p>
+<b>Arrays</b>
+</p>
+
+<p>
+The slice type is an abstraction built on top of Go's array type, and so to
+understand slices we must first understand arrays.
+</p>
+
+<p>
+An array type definition specifies a length and an element type. For example,
+the type <code>[4]int</code> represents an array of four integers. An array's
+size is fixed; its length is part of its type (<code>[4]int</code> and
+<code>[5]int</code> are distinct, incompatible types). Arrays can be indexed in
+the usual way, so the expression <code>s[n]</code> accesses the <i>n</i>th
+element:
+</p>
+
+<pre>
+var a [4]int
+a[0] = 1
+i := a[0]
+// i == 1
+</pre>
+
+<p>
+Arrays do not need to be initialized explicitly; the zero value of an array is
+a ready-to-use array whose elements are themselves zeroed:
+</p>
+
+<pre>
+// a[2] == 0, the zero value of the int type
+</pre>
+
+<p>
+The in-memory representation of <code>[4]int</code> is just four integer values laid out sequentially:
+</p>
+
+<p>
+<img src="slice-array.png">
+</p>
+
+<p>
+Go's arrays are values. An array variable denotes the entire array; it is not a
+pointer to the first array element (as would be the case in C).  This means
+that when you assign or pass around an array value you will make a copy of its
+contents. (To avoid the copy you could pass a <i>pointer</i> to the array, but
+then that's a pointer to an array, not an array.) One way to think about arrays
+is as a sort of struct but with indexed rather than named fields: a fixed-size
+composite value.
+</p>
+
+<p>
+An array literal can be specified like so:
+</p>
+
+<pre>
+b := [2]string{"Penn", "Teller"}
+</pre>
+
+<p>
+Or, you can have the compiler count the array elements for you:
+</p>
+
+<pre>
+b := [...]string{"Penn", "Teller"}
+</pre>
+
+<p>
+In both cases, the type of <code>b</code> is <code>[2]string</code>.
+</p>
+
+<p>
+<b>Slices</b>
+</p>
+
+<p>
+Arrays have their place, but they're a bit inflexible, so you don't see them
+too often in Go code. Slices, though, are everywhere. They build on arrays to
+provide great power and convenience.
+</p>
+
+<p>
+The type specification for a slice is <code>[]T</code>, where <code>T</code> is
+the type of the elements of the slice. Unlike an array type, a slice type has
+no specified length.
+</p>
+
+<p>
+A slice literal is declared just like an array literal, except you leave out
+the element count:
+</p>
+
+<pre>
+letters := []string{"a", "b", "c", "d"}
+</pre>
+
+<p>
+A slice can be created with the built-in function called <code>make</code>,
+which has the signature,
+</p>
+
+<pre>
+func make([]T, len, cap) []T
+</pre>
+
+<p>
+where T stands for the element type of the slice to be created. The
+<code>make</code> function takes a type, a length, and an optional capacity.
+When called, <code>make</code> allocates an array and returns a slice that
+refers to that array.
+</p>
+
+<pre>
+var s []byte
+s = make([]byte, 5, 5)
+// s == []byte{0, 0, 0, 0, 0}
+</pre>
+
+<p>
+When the capacity argument is omitted, it defaults to the specified length.
+Here's a more succinct version of the same code:
+</p>
+
+<pre>
+s := make([]byte, 5)
+</pre>
+
+<p>
+The length and capacity of a slice can be inspected using the built-in
+<code>len</code> and <code>cap</code> functions.
+</p>
+
+<pre>
+len(s) == 5
+cap(s) == 5
+</pre>
+
+<p>
+The next two sections discuss the relationship between length and capacity.
+</p>
+
+<p>
+The zero value of a slice is <code>nil</code>. The <code>len</code> and
+<code>cap</code> functions will both return 0 for a nil slice.
+</p>
+
+<p>
+A slice can also be formed by "slicing" an existing slice or array. Slicing is
+done by specifying a half-open range with two indices separated by a colon. For
+example, the expression <code>b[1:4]</code> creates a slice including elements
+1 through 3 of <code>b</code> (the indices of the resulting slice will be 0
+through 2).
+</p>
+
+<pre>
+b := []byte{'g', 'o', 'l', 'a', 'n', 'g'}
+// b[1:4] == []byte{'o', 'l', 'a'}, sharing the same storage as b
+</pre>
+
+<p>
+The start and end indices of a slice expression are optional; they default to zero and the slice's length respectively:
+</p>
+
+<pre>
+// b[:2] == []byte{'g', 'o'}
+// b[2:] == []byte{'l', 'a', 'n', 'g'}
+// b[:] == b
+</pre>
+
+<p>
+This is also the syntax to create a slice given an array:
+</p>
+
+<pre>
+x := [3]string{"Лайка", "Белка", "Стрелка"}
+s := x[:] // a slice referencing the storage of x
+</pre>
+
+<p>
+<b>Slice internals</b>
+</p>
+
+<p>
+A slice is a descriptor of an array segment. It consists of a pointer to the
+array, the length of the segment, and its capacity (the maximum length of the
+segment).
+</p>
+
+<p>
+<img src="slice-struct.png">
+</p>
+
+<p>
+Our variable <code>s</code>, created earlier by <code>make([]byte, 5)</code>,
+is structured like this:
+</p>
+
+<p>
+<img src="slice-1.png">
+</p>
+
+<p>
+The length is the number of elements referred to by the slice. The capacity is
+the number of elements in the underlying array (beginning at the element
+referred to by the slice pointer). The distinction between length and capacity
+will be made clear as we walk through the next few examples.
+</p>
+
+<p>
+As we slice <code>s</code>, observe the changes in the slice data structure and
+their relation to the underlying array:
+</p>
+
+<pre>
+s = s[2:4]
+</pre>
+
+<p>
+<img src="slice-2.png">
+</p>
+
+<p>
+Slicing does not copy the slice's data. It creates a new slice value that
+points to the original array. This makes slice operations as efficient as
+manipulating array indices. Therefore, modifying the <i>elements</i> (not the
+slice itself) of a re-slice modifies the elements of the original slice:
+</p>
+
+<pre>
+d := []byte{'r', 'o', 'a', 'd'}
+e := d[2:] 
+// e == []byte{'a', 'd'}
+e[1] == 'm'
+// e == []byte{'a', 'm'}
+// d == []byte{'r', 'o', 'a', 'm'}
+</pre>
+
+<p>
+Earlier we sliced <code>s</code> to a length shorter than its capacity. We can
+grow s to its capacity by slicing it again:
+</p>
+
+<pre>
+s = s[:cap(s)]
+</pre>
+
+<p>
+<img src="slice-3.png">
+</p>
+
+<p>
+A slice cannot be grown beyond its capacity. Attempting to do so will cause a
+runtime panic, just as when indexing outside the bounds of a slice or array.
+Similarly, slices cannot be re-sliced below zero to access earlier elements in
+the array.
+</p>
+
+<p>
+<b>Growing slices (the copy and append functions)</b>
+</p>
+
+<p>
+To increase the capacity of a slice one must create a new, larger slice and
+copy the contents of the original slice into it. This technique is how dynamic
+array implementations from other languages work behind the scenes. The next
+example doubles the capacity of <code>s</code> by making a new slice,
+<code>t</code>, copying the contents of <code>s</code> into <code>t</code>, and
+then assigning the slice value <code>t</code> to <code>s</code>:
+</p>
+
+<pre>
+t := make([]byte, len(s), (cap(s)+1)*2) // +1 in case cap(s) == 0
+for i := range s {
+        t[i] = s[i]
+}
+s = t
+</pre>
+
+<p>
+The looping piece of this common operation is made easier by the built-in copy
+function. As the name suggests, copy copies data from a source slice to a
+destination slice. It returns the number of elements copied.
+</p>
+
+<pre>
+func copy(dst, src []T) int
+</pre>
+
+<p>
+The <code>copy</code> function supports copying between slices of different
+lengths (it will copy only up to the smaller number of elements). In addition,
+<code>copy</code> can handle source and destination slices that share the same
+underlying array, handling overlapping slices correctly.
+</p>
+
+<p>
+Using <code>copy</code>, we can simplify the code snippet above:
+</p>
+
+<pre>
+t := make([]byte, len(s), (cap(s)+1)*2)
+copy(t, s)
+s = t
+</pre>
+
+<p>
+A common operation is to append data to the end of a slice. This function
+appends byte elements to a slice of bytes, growing the slice if necessary, and
+returns the updated slice value:
+</p>
+
+{{code "progs/slices.go" `/AppendByte/` `/STOP/`}}
+
+<p>
+One could use <code>AppendByte</code> like this:
+</p>
+
+<pre>
+p := []byte{2, 3, 5}
+p = AppendByte(p, 7, 11, 13)
+// p == []byte{2, 3, 5, 7, 11, 13}
+</pre>
+
+<p>
+Functions like <code>AppendByte</code> are useful because they offer complete
+control over the way the slice is grown. Depending on the characteristics of
+the program, it may be desirable to allocate in smaller or larger chunks, or to
+put a ceiling on the size of a reallocation.
+</p>
+
+<p>
+But most programs don't need complete control, so Go provides a built-in
+<code>append</code> function that's good for most purposes; it has the
+signature
+</p>
+
+<pre>
+func append(s []T, x ...T) []T 
+</pre>
+
+<p>
+The <code>append</code> function appends the elements <code>x</code> to the end
+of the slice <code>s</code>, and grows the slice if a greater capacity is
+needed.
+</p>
+
+<pre>
+a := make([]int, 1)
+// a == []int{0}
+a = append(a, 1, 2, 3)
+// a == []int{0, 1, 2, 3}
+</pre>
+
+<p>
+To append one slice to another, use <code>...</code> to expand the second
+argument to a list of arguments.
+</p>
+
+<pre>
+a := []string{"John", "Paul"}
+b := []string{"George", "Ringo", "Pete"}
+a = append(a, b...) // equivalent to "append(a, b[0], b[1], b[2])"
+// a == []string{"John", "Paul", "George", "Ringo", "Pete"}
+</pre>
+
+<p>
+Since the zero value of a slice (<code>nil</code>) acts like a zero-length
+slice, you can declare a slice variable and then append to it in a loop:
+</p>
+
+{{code "progs/slices.go" `/Filter/` `/STOP/`}}
+
+<p>
+<b>A possible "gotcha"</b>
+</p>
+
+<p>
+As mentioned earlier, re-slicing a slice doesn't make a copy of the underlying
+array. The full array will be kept in memory until it is no longer referenced.
+Occasionally this can cause the program to hold all the data in memory when
+only a small piece of it is needed.
+</p>
+
+<p>
+For example, this <code>FindDigits</code> function loads a file into memory and
+searches it for the first group of consecutive numeric digits, returning them
+as a new slice.
+</p>
+
+{{code "progs/slices.go" `/digit/` `/STOP/`}}
+
+<p>
+This code behaves as advertised, but the returned <code>[]byte</code> points
+into an array containing the entire file. Since the slice references the
+original array, as long as the slice is kept around the garbage collector can't
+release the array; the few useful bytes of the file keep the entire contents in
+memory.
+</p>
+
+<p>
+To fix this problem one can copy the interesting data to a new slice before
+returning it:
+</p>
+
+{{code "progs/slices.go" `/CopyDigits/` `/STOP/`}}
+
+<p>
+A more concise version of this function could be constructed by using
+<code>append</code>. This is left as an exercise for the reader.
+</p>
+
+<p>
+<b>Further Reading</b>
+</p>
+
+<p>
+<a href="/doc/effective_go.html">Effective Go</a> contains an
+in-depth treatment of <a href="/doc/effective_go.html#slices">slices</a>
+and <a href="/doc/effective_go.html#arrays">arrays</a>, 
+and the Go <a href="/doc/go_spec.html">language specification</a>
+defines <a href="/doc/go_spec.html#Slice_types">slices</a> and their
+<a href="/doc/go_spec.html#Length_and_capacity">associated</a>
+<a href="/doc/go_spec.html#Making_slices_maps_and_channels">helper</a>
+<a href="/doc/go_spec.html#Appending_and_copying_slices">functions</a>.
+</p>
diff --git a/doc/progs/run b/doc/progs/run
index 9cb6f8d79f1..2a76d6b2da0 100755
--- a/doc/progs/run
+++ b/doc/progs/run
@@ -61,6 +61,7 @@ for i in \
 	$effective_go \
 	$error_handling \
 	$go_tutorial \
+	slices.go \
 	go1.go \
 ; do
 	$GC $i
diff --git a/doc/progs/slices.go b/doc/progs/slices.go
new file mode 100644
index 00000000000..be4322a3282
--- /dev/null
+++ b/doc/progs/slices.go
@@ -0,0 +1,55 @@
+package main
+
+import (
+	"io/ioutil"
+	"regexp"
+)
+
+func AppendByte(slice []byte, data ...byte) []byte {
+	m := len(slice)
+	n := m + len(data)
+	if n > cap(slice) { // if necessary, reallocate
+		// allocate double what's needed, for future growth.
+		newSlice := make([]byte, (n+1)*2)
+		copy(newSlice, slice)
+		slice = newSlice
+	}
+	slice = slice[0:n]
+	copy(slice[m:n], data)
+	return slice
+}
+
+// STOP OMIT
+
+// Filter returns a new slice holding only
+// the elements of s that satisfy f()
+func Filter(s []int, fn func(int) bool) []int {
+	var p []int // == nil
+	for _, i := range s {
+		if fn(i) {
+			p = append(p, i)
+		}
+	}
+	return p
+}
+
+// STOP OMIT
+
+var digitRegexp = regexp.MustCompile("[0-9]+")
+
+func FindDigits(filename string) []byte {
+	b, _ := ioutil.ReadFile(filename)
+	return digitRegexp.Find(b)
+}
+
+// STOP OMIT
+
+func CopyDigits(filename string) []byte {
+	b, _ := ioutil.ReadFile(filename)
+	b = digitRegexp.Find(b)
+	c := make([]byte, len(b))
+	copy(c, b)
+	return c
+}
+
+// STOP OMIT